[CodeCompletion] Split CodeCompletionConsumer into its own file

Author: ahoppen

include/swift/IDE/CodeCompletion.h

@@ -20,6 +20,7 @@
 #include "swift/Basic/OptionSet.h"
 #include "swift/Basic/StringExtras.h"
 #include "swift/Frontend/Frontend.h"
+#include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionContext.h"
 #include "swift/IDE/CodeCompletionResult.h"
 #include "swift/IDE/CodeCompletionResultSink.h"
@@ -103,30 +104,10 @@ struct SwiftCompletionInfo {
   CodeCompletionContext *completionContext = nullptr;
 };
 
-/// An abstract base class for consumers of code completion results.
-/// \see \c SimpleCachingCodeCompletionConsumer.
-class CodeCompletionConsumer {
-public:
-  virtual ~CodeCompletionConsumer() {}
-  virtual void
-  handleResultsAndModules(CodeCompletionContext &context,
-                          ArrayRef<RequestedCachedModule> requestedModules,
-                          DeclContext *DC) = 0;
-};
-
-/// A simplified code completion consumer interface that clients can use to get
-/// CodeCompletionResults with automatic caching of top-level completions from
-/// imported modules.
-struct SimpleCachingCodeCompletionConsumer : public CodeCompletionConsumer {
+void postProcessResults(MutableArrayRef<CodeCompletionResult *> results,
+                        CompletionKind Kind, DeclContext *DC,
+                        CodeCompletionResultSink *Sink);
 
-  // Implement the CodeCompletionConsumer interface.
-  void handleResultsAndModules(CodeCompletionContext &context,
-                               ArrayRef<RequestedCachedModule> requestedModules,
-                               DeclContext *DCForModules) override;
-
-  /// Clients should override this method to receive \p Results.
-  virtual void handleResults(CodeCompletionContext &context) = 0;
-};
 
 /// Create a factory for code completion callbacks.
 CodeCompletionCallbacksFactory *

include/swift/IDE/CodeCompletionConsumer.h

@@ -0,0 +1,52 @@
+//===--- CodeCompletionConsumer.h -----------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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 SWIFT_IDE_CODECOMPLETIONCONSUMER
+#define SWIFT_IDE_CODECOMPLETIONCONSUMER
+
+#include "swift/IDE/CodeCompletionContext.h"
+#include "swift/Parse/CodeCompletionCallbacks.h"
+
+namespace swift {
+namespace ide {
+
+struct RequestedCachedModule;
+
+/// An abstract base class for consumers of code completion results.
+/// \see \c SimpleCachingCodeCompletionConsumer.
+class CodeCompletionConsumer {
+public:
+  virtual ~CodeCompletionConsumer() {}
+  virtual void
+  handleResultsAndModules(CodeCompletionContext &context,
+                          ArrayRef<RequestedCachedModule> requestedModules,
+                          DeclContext *DC) = 0;
+};
+
+/// A simplified code completion consumer interface that clients can use to get
+/// CodeCompletionResults with automatic caching of top-level completions from
+/// imported modules.
+struct SimpleCachingCodeCompletionConsumer : public CodeCompletionConsumer {
+
+  // Implement the CodeCompletionConsumer interface.
+  void handleResultsAndModules(CodeCompletionContext &context,
+                               ArrayRef<RequestedCachedModule> requestedModules,
+                               DeclContext *DCForModules) override;
+
+  /// Clients should override this method to receive \p Results.
+  virtual void handleResults(CodeCompletionContext &context) = 0;
+};
+
+} // end namespace ide
+} // end namespace swift
+
+#endif // SWIFT_IDE_CODECOMPLETIONCONSUMER

include/swift/IDE/REPLCodeCompletion.h

@@ -20,13 +20,14 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/IDE/CodeCompletion.h"
 #include "swift/IDE/CodeCompletionCache.h"
+#include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
-#include <vector>
 #include <string>
 #include <utility>
+#include <vector>
 
 namespace swift {
 

lib/IDE/CMakeLists.txt

@@ -3,6 +3,7 @@ add_swift_host_library(swiftIDE STATIC
   CodeCompletion.cpp
   CodeCompletionCache.cpp
   CodeCompletionContext.cpp
+  CodeCompletionConsumer.cpp
   CodeCompletionDiagnostics.cpp
   CodeCompletionResultBuilder.cpp
   CodeCompletionResultPrinter.cpp

lib/IDE/CodeCompletion.cpp

@@ -33,6 +33,7 @@
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Frontend/FrontendOptions.h"
 #include "swift/IDE/CodeCompletionCache.h"
+#include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionResultPrinter.h"
 #include "swift/IDE/CodeCompletionStringPrinter.h"
 #include "swift/IDE/CompletionLookup.h"
@@ -1156,9 +1157,9 @@ static void addConditionalCompilationFlags(ASTContext &Ctx,
 /// If \p Sink is passed, the pointer of the each result may be replaced with a
 /// pointer to the new item allocated in \p Sink.
 /// If \p Sink is nullptr, the pointee of each result may be modified in place.
-static void postProcessResults(MutableArrayRef<CodeCompletionResult *> results,
-                               CompletionKind Kind, DeclContext *DC,
-                               CodeCompletionResultSink *Sink) {
+void swift::ide::postProcessResults(
+    MutableArrayRef<CodeCompletionResult *> results, CompletionKind Kind,
+    DeclContext *DC, CodeCompletionResultSink *Sink) {
   for (CodeCompletionResult *&result : results) {
     bool modified = false;
     auto flair = result->getFlair();
@@ -2065,132 +2066,6 @@ void swift::ide::lookupCodeCompletionResultsFromModule(
   Lookup.lookupExternalModuleDecls(module, accessPath, needLeadingDot);
 }
 
-static MutableArrayRef<CodeCompletionResult *>
-copyCodeCompletionResults(CodeCompletionResultSink &targetSink,
-                          CodeCompletionCache::Value &source, bool onlyTypes,
-                          bool onlyPrecedenceGroups) {
-
-  // We will be adding foreign results (from another sink) into TargetSink.
-  // TargetSink should have an owning pointer to the allocator that keeps the
-  // results alive.
-  targetSink.ForeignAllocators.push_back(source.Allocator);
-  auto startSize = targetSink.Results.size();
-
-  std::function<bool(const ContextFreeCodeCompletionResult *)>
-      shouldIncludeResult;
-  if (onlyTypes) {
-    shouldIncludeResult = [](const ContextFreeCodeCompletionResult *R) -> bool {
-      if (R->getKind() != CodeCompletionResultKind::Declaration)
-        return false;
-      switch (R->getAssociatedDeclKind()) {
-      case CodeCompletionDeclKind::Module:
-      case CodeCompletionDeclKind::Class:
-      case CodeCompletionDeclKind::Actor:
-      case CodeCompletionDeclKind::Struct:
-      case CodeCompletionDeclKind::Enum:
-      case CodeCompletionDeclKind::Protocol:
-      case CodeCompletionDeclKind::TypeAlias:
-      case CodeCompletionDeclKind::AssociatedType:
-      case CodeCompletionDeclKind::GenericTypeParam:
-        return true;
-      case CodeCompletionDeclKind::PrecedenceGroup:
-      case CodeCompletionDeclKind::EnumElement:
-      case CodeCompletionDeclKind::Constructor:
-      case CodeCompletionDeclKind::Destructor:
-      case CodeCompletionDeclKind::Subscript:
-      case CodeCompletionDeclKind::StaticMethod:
-      case CodeCompletionDeclKind::InstanceMethod:
-      case CodeCompletionDeclKind::PrefixOperatorFunction:
-      case CodeCompletionDeclKind::PostfixOperatorFunction:
-      case CodeCompletionDeclKind::InfixOperatorFunction:
-      case CodeCompletionDeclKind::FreeFunction:
-      case CodeCompletionDeclKind::StaticVar:
-      case CodeCompletionDeclKind::InstanceVar:
-      case CodeCompletionDeclKind::LocalVar:
-      case CodeCompletionDeclKind::GlobalVar:
-        return false;
-      }
-
-      llvm_unreachable("Unhandled CodeCompletionDeclKind in switch.");
-    };
-  } else if (onlyPrecedenceGroups) {
-    shouldIncludeResult = [](const ContextFreeCodeCompletionResult *R) -> bool {
-      return R->getAssociatedDeclKind() ==
-             CodeCompletionDeclKind::PrecedenceGroup;
-    };
-  } else {
-    shouldIncludeResult = [](const ContextFreeCodeCompletionResult *R) -> bool {
-      return true;
-    };
-  }
-  for (auto contextFreeResult : source.Results) {
-    if (!shouldIncludeResult(contextFreeResult)) {
-      continue;
-    }
-    auto contextualResult = new (*targetSink.Allocator) CodeCompletionResult(
-        *contextFreeResult, SemanticContextKind::OtherModule,
-        CodeCompletionFlair(),
-        /*numBytesToErase=*/0, /*TypeContext=*/nullptr, /*DC=*/nullptr,
-        ContextualNotRecommendedReason::None,
-        CodeCompletionDiagnosticSeverity::None, /*DiagnosticMessage=*/"");
-    targetSink.Results.push_back(contextualResult);
-  }
-
-  return llvm::makeMutableArrayRef(targetSink.Results.data() + startSize,
-                                   targetSink.Results.size() - startSize);
-}
-
-void SimpleCachingCodeCompletionConsumer::handleResultsAndModules(
-    CodeCompletionContext &context,
-    ArrayRef<RequestedCachedModule> requestedModules,
-    DeclContext *DC) {
-
-  // Use the current SourceFile as the DeclContext so that we can use it to
-  // perform qualified lookup, and to get the correct visibility for
-  // @testable imports. Also it cannot use 'DC' since it would apply decl
-  // context changes to cached results.
-  const SourceFile *SF = DC->getParentSourceFile();
-
-  for (auto &R : requestedModules) {
-    // FIXME(thread-safety): lock the whole AST context.  We might load a
-    // module.
-    llvm::Optional<CodeCompletionCache::ValueRefCntPtr> V =
-        context.Cache.get(R.Key);
-    if (!V.hasValue()) {
-      // No cached results found. Fill the cache.
-      V = context.Cache.createValue();
-      // Temporary sink in which we gather the result. The cache value retains
-      // the sink's allocator.
-      CodeCompletionResultSink Sink;
-      Sink.annotateResult = context.getAnnotateResult();
-      Sink.addInitsToTopLevel = context.getAddInitsToTopLevel();
-      Sink.enableCallPatternHeuristics = context.getCallPatternHeuristics();
-      Sink.includeObjectLiterals = context.includeObjectLiterals();
-      Sink.addCallWithNoDefaultArgs = context.addCallWithNoDefaultArgs();
-      lookupCodeCompletionResultsFromModule(Sink, R.TheModule, R.Key.AccessPath,
-                                            R.Key.ResultsHaveLeadingDot, SF);
-      (*V)->Allocator = Sink.Allocator;
-      auto &CachedResults = (*V)->Results;
-      CachedResults.reserve(Sink.Results.size());
-      // Instead of copying the context free results out of the sink's allocator
-      // retain the sink's entire allocator (which also includes the contextual
-      // properities) and simply store pointers to the context free results that
-      // back the contextual results.
-      for (auto Result : Sink.Results) {
-        CachedResults.push_back(Result->getContextFreeResultPtr());
-      }
-      context.Cache.set(R.Key, *V);
-    }
-    assert(V.hasValue());
-    auto newItems = copyCodeCompletionResults(
-        context.getResultSink(), **V, R.OnlyTypes, R.OnlyPrecedenceGroups);
-    postProcessResults(newItems, context.CodeCompletionKind, DC,
-                       &context.getResultSink());
-  }
-
-  handleResults(context);
-}
-
 //===----------------------------------------------------------------------===//
 // ImportDepth
 //===----------------------------------------------------------------------===//