Merge pull request swiftlang#33632 from benlangmuir/gardening-libIDE

[gardening] Move some code between sourcekitd and libIDE

Author: benlangmuir

include/swift/IDE/CodeCompletionResultPrinter.h

@@ -34,6 +34,12 @@ void printCodeCompletionResultTypeName(
 void printCodeCompletionResultTypeNameAnnotated(
     const CodeCompletionResult &Result, llvm::raw_ostream &OS);
 
+void printCodeCompletionResultSourceText(
+    const CodeCompletionResult &Result, llvm::raw_ostream &OS);
+
+void printCodeCompletionResultFilterName(
+    const CodeCompletionResult &Result, llvm::raw_ostream &OS);
+
 } // namespace ide
 } // namespace swift
 

tools/SourceKit/include/SourceKit/Support/FuzzyStringMatcher.h renamed to include/swift/IDE/FuzzyStringMatcher.h

@@ -2,22 +2,23 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SOURCEKIT_LIB_SUPPORT_FUZZYSTRINGMATCHER_H
-#define LLVM_SOURCEKIT_LIB_SUPPORT_FUZZYSTRINGMATCHER_H
+#ifndef SWIFT_IDE_FUZZYSTRINGMATCHER_H
+#define SWIFT_IDE_FUZZYSTRINGMATCHER_H
 
-#include "SourceKit/Core/LLVM.h"
+#include "swift/Basic/LLVM.h"
 #include "llvm/ADT/BitVector.h"
 #include <string>
 
-namespace SourceKit {
+namespace swift {
+namespace ide {
 
 /// FuzzyStringMatcher compares candidate strings against a pattern
 /// string using a fuzzy matching algorithm and provides a numerical
@@ -49,6 +50,7 @@ class FuzzyStringMatcher {
   double scoreCandidate(StringRef candidate) const;
 };
 
-} // end namespace SourceKit
+} // namespace ide
+} // namespace swift
 
-#endif // LLVM_SOURCEKIT_LIB_SUPPORT_FUZZYSTRINGMATCHER_H
+#endif // SWIFT_IDE_FUZZYSTRINGMATCHER_H

include/swift/IDE/Utils.h

@@ -81,6 +81,14 @@ SourceCompleteResult
 isSourceInputComplete(std::unique_ptr<llvm::MemoryBuffer> MemBuf, SourceFileKind SFKind);
 SourceCompleteResult isSourceInputComplete(StringRef Text, SourceFileKind SFKind);
 
+bool initCompilerInvocation(
+    CompilerInvocation &Invocation, ArrayRef<const char *> OrigArgs,
+    DiagnosticEngine &Diags, StringRef UnresolvedPrimaryFile,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem,
+    const std::string &runtimeResourcePath,
+    const std::string &diagnosticDocumentationPath,
+    bool shouldOptimizeForIDE, time_t sessionTimestamp, std::string &Error);
+
 bool initInvocationByClangArguments(ArrayRef<const char *> ArgList,
                                     CompilerInvocation &Invok,
                                     std::string &Error);

lib/IDE/CMakeLists.txt

@@ -7,6 +7,7 @@ add_swift_host_library(swiftIDE STATIC
   ConformingMethodList.cpp
   ExprContextAnalysis.cpp
   Formatting.cpp
+  FuzzyStringMatcher.cpp
   Refactoring.cpp
   ModuleInterfacePrinting.cpp
   REPLCodeCompletion.cpp
@@ -21,6 +22,7 @@ add_swift_host_library(swiftIDE STATIC
 target_link_libraries(swiftIDE PRIVATE
   swiftAST
   swiftClangImporter
+  swiftDriver
   swiftFrontend
   swiftIndex
   swiftParse

lib/IDE/CodeCompletionResultPrinter.cpp

@@ -10,8 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/Basic/LLVM.h"
 #include "swift/IDE/CodeCompletionResultPrinter.h"
+#include "swift/AST/ASTPrinter.h"
+#include "swift/Basic/LLVM.h"
 #include "swift/IDE/CodeCompletion.h"
 #include "swift/Markup/XMLUtils.h"
 #include "llvm/Support/raw_ostream.h"
@@ -255,3 +256,186 @@ void swift::ide::printCodeCompletionResultTypeNameAnnotated(const CodeCompletion
   AnnotatingResultPrinter printer(OS);
   printer.printTypeName(Result);
 }
+
+/// Provide the text for the call parameter, including constructing a typed
+/// editor placeholder for it.
+static void
+constructTextForCallParam(ArrayRef<CodeCompletionString::Chunk> ParamGroup,
+                          raw_ostream &OS) {
+  assert(ParamGroup.front().is(ChunkKind::CallParameterBegin));
+
+  for (; !ParamGroup.empty(); ParamGroup = ParamGroup.slice(1)) {
+    auto &C = ParamGroup.front();
+    if (C.isAnnotation())
+      continue;
+    if (C.is(ChunkKind::CallParameterInternalName) ||
+        C.is(ChunkKind::CallParameterType) ||
+        C.is(ChunkKind::CallParameterTypeBegin) ||
+        C.is(ChunkKind::CallParameterClosureExpr)) {
+      break;
+    }
+    if (!C.hasText())
+      continue;
+    OS << C.getText();
+  }
+
+  SmallString<32> DisplayString;
+  SmallString<32> TypeString;
+  SmallString<32> ExpansionTypeString;
+
+  for (auto i = ParamGroup.begin(), e = ParamGroup.end(); i != e; ++i) {
+    auto &C = *i;
+    if (C.is(ChunkKind::CallParameterTypeBegin)) {
+      assert(TypeString.empty());
+      auto nestingLevel = C.getNestingLevel();
+      ++i;
+      for (; i != e; ++i) {
+        if (i->endsPreviousNestedGroup(nestingLevel))
+          break;
+        if (!i->isAnnotation() && i->hasText()) {
+          TypeString += i->getText();
+          DisplayString += i->getText();
+        }
+      }
+      --i;
+      continue;
+    }
+    if (C.is(ChunkKind::CallParameterClosureType)) {
+      assert(ExpansionTypeString.empty());
+      ExpansionTypeString = C.getText();
+      continue;
+    }
+    if (C.is(ChunkKind::CallParameterType)) {
+      assert(TypeString.empty());
+      TypeString = C.getText();
+    }
+    if (C.is(ChunkKind::CallParameterClosureExpr)) {
+      // We have a closure expression, so provide it directly instead of in
+      // a placeholder.
+      OS << "{";
+      if (!C.getText().empty())
+        OS << " " << C.getText();
+      OS << "\n" << getCodePlaceholder() << "\n}";
+      return;
+    }
+    if (C.isAnnotation() || !C.hasText())
+      continue;
+    DisplayString += C.getText();
+  }
+
+  StringRef Display = DisplayString.str();
+  StringRef Type = TypeString.str();
+  StringRef ExpansionType = ExpansionTypeString.str();
+  if (ExpansionType.empty())
+    ExpansionType = Type;
+
+  OS << "<#T##" << Display;
+  if (Display == Type && Display == ExpansionType) {
+    // Short version, display and type are the same.
+  } else {
+    OS << "##" << Type;
+    if (ExpansionType != Type)
+      OS << "##" << ExpansionType;
+  }
+  OS << "#>";
+}
+
+void swift::ide::printCodeCompletionResultSourceText(
+    const CodeCompletionResult &Result, llvm::raw_ostream &OS) {
+  auto Chunks = Result.getCompletionString()->getChunks();
+  for (size_t i = 0; i < Chunks.size(); ++i) {
+    auto &C = Chunks[i];
+    if (C.is(ChunkKind::BraceStmtWithCursor)) {
+      OS << " {\n" << getCodePlaceholder() << "\n}";
+      continue;
+    }
+    if (C.is(ChunkKind::CallParameterBegin)) {
+      size_t Start = i++;
+      for (; i < Chunks.size(); ++i) {
+        if (Chunks[i].endsPreviousNestedGroup(C.getNestingLevel()))
+          break;
+      }
+      constructTextForCallParam(Chunks.slice(Start, i - Start), OS);
+      --i;
+      continue;
+    }
+    if (C.is(ChunkKind::TypeAnnotationBegin)) {
+      // Skip type annotation structure.
+      auto level = C.getNestingLevel();
+      do {
+        ++i;
+      } while (i != Chunks.size() && !Chunks[i].endsPreviousNestedGroup(level));
+      --i;
+    }
+    if (!C.isAnnotation() && C.hasText()) {
+      OS << C.getText();
+    }
+  }
+}
+
+void swift::ide::printCodeCompletionResultFilterName(
+    const CodeCompletionResult &Result, llvm::raw_ostream &OS) {
+  auto str = Result.getCompletionString();
+  // FIXME: we need a more uniform way to handle operator completions.
+  if (str->getChunks().size() == 1 && str->getChunks()[0].is(ChunkKind::Dot)) {
+    OS << ".";
+    return;
+  } else if (str->getChunks().size() == 2 &&
+             str->getChunks()[0].is(ChunkKind::QuestionMark) &&
+             str->getChunks()[1].is(ChunkKind::Dot)) {
+    OS << "?.";
+    return;
+  }
+
+  auto FirstTextChunk = str->getFirstTextChunkIndex();
+  if (FirstTextChunk.hasValue()) {
+    auto chunks = str->getChunks().slice(*FirstTextChunk);
+    for (auto i = chunks.begin(), e = chunks.end(); i != e; ++i) {
+      auto &C = *i;
+
+      if (C.is(ChunkKind::BraceStmtWithCursor))
+        break; // Don't include brace-stmt in filter name.
+
+      if (C.is(ChunkKind::Equal)) {
+        OS << C.getText();
+        break;
+      }
+
+      bool shouldPrint = !C.isAnnotation();
+      switch (C.getKind()) {
+      case ChunkKind::TypeAnnotation:
+      case ChunkKind::CallParameterInternalName:
+      case ChunkKind::CallParameterClosureType:
+      case ChunkKind::CallParameterClosureExpr:
+      case ChunkKind::CallParameterType:
+      case ChunkKind::DeclAttrParamColon:
+      case ChunkKind::Comma:
+      case ChunkKind::Whitespace:
+      case ChunkKind::Ellipsis:
+      case ChunkKind::Ampersand:
+      case ChunkKind::OptionalMethodCallTail:
+        continue;
+      case ChunkKind::CallParameterTypeBegin:
+      case ChunkKind::TypeAnnotationBegin: {
+        // Skip call parameter type or type annotation structure.
+        auto nestingLevel = C.getNestingLevel();
+        do {
+          ++i;
+        } while (i != e && !i->endsPreviousNestedGroup(nestingLevel));
+        --i;
+        continue;
+      }
+      case ChunkKind::CallParameterColon:
+        // Since we don't add the type, also don't add the space after ':'.
+        if (shouldPrint)
+          OS << ":";
+        continue;
+      default:
+        break;
+      }
+
+      if (C.hasText() && shouldPrint)
+        OS << C.getText();
+    }
+  }
+}

tools/SourceKit/lib/Support/FuzzyStringMatcher.cpp renamed to lib/IDE/FuzzyStringMatcher.cpp

@@ -2,20 +2,21 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
-#include "SourceKit/Support/FuzzyStringMatcher.h"
+#include "swift/IDE/FuzzyStringMatcher.h"
 #include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 
-using namespace SourceKit;
+using namespace swift;
+using namespace swift::ide;
 using clang::toUppercase;
 using clang::toLowercase;
 using clang::isUppercase;