[Code Completion] Split code completion results into context free part that can be cached and contextual part displayed to the user

This allows makes the distinction between cachable and non-cachable properties cleaner and allows us to more easily compute contextual information (like type relations) for cached items later.

Author: ahoppen

include/swift/IDE/CodeCompletion.h

@@ -58,8 +58,16 @@ class CodeCompletionCache {
   };
 
   struct Value : public llvm::ThreadSafeRefCountedBase<Value> {
+    using AllocatorPtr = std::shared_ptr<llvm::BumpPtrAllocator>;
+
+    /// The allocator used to allocate the results stored in this cache.
+    AllocatorPtr Allocator;
+
     llvm::sys::TimePoint<> ModuleModificationTime;
-    CodeCompletionResultSink Sink;
+
+    std::vector<ContextFreeCodeCompletionResult *> Results;
+
+    Value() : Allocator(std::make_shared<llvm::BumpPtrAllocator>()) {}
   };
   using ValueRefCntPtr = llvm::IntrusiveRefCntPtr<Value>;
 

include/swift/IDE/CodeCompletionCache.h

@@ -41,7 +41,7 @@ namespace swift {
     struct CacheValueCostInfo<swift::ide::CodeCompletionCacheImpl::Value> {
       static size_t
       getCost(const swift::ide::CodeCompletionCacheImpl::Value &V) {
-        return V.Sink.Allocator->getTotalMemory();
+        return V.Allocator->getTotalMemory();
       }
     };
   } // namespace sys
@@ -102,7 +102,8 @@ CodeCompletionCache::~CodeCompletionCache() {}
 ///
 /// This should be incremented any time we commit a change to the format of the
 /// cached results. This isn't expected to change very often.
-static constexpr uint32_t onDiskCompletionCacheVersion = 3; // Removed "source file path".
+static constexpr uint32_t onDiskCompletionCacheVersion =
+    4; // Store ContextFreeCodeCompletionResults in cache
 
 /// Deserializes CodeCompletionResults from \p in and stores them in \p V.
 /// \see writeCacheModule.
@@ -166,7 +167,7 @@ static bool readCachedModule(llvm::MemoryBuffer *in,
 
     const char *p = strings + index;
     auto size = read32le(p);
-    auto str = copyString(*V.Sink.Allocator, StringRef(p, size));
+    auto str = copyString(*V.Allocator, StringRef(p, size));
     knownStrings[index] = str;
     return str;
   };
@@ -192,21 +193,19 @@ static bool readCachedModule(llvm::MemoryBuffer *in,
       }
     }
 
-    return CodeCompletionString::create(*V.Sink.Allocator, chunkList);
+    return CodeCompletionString::create(*V.Allocator, chunkList);
   };
 
   // RESULTS
   while (cursor != resultEnd) {
-    auto kind = static_cast<CodeCompletionResult::ResultKind>(*cursor++);
+    auto kind = static_cast<CodeCompletionResultKind>(*cursor++);
     auto declKind = static_cast<CodeCompletionDeclKind>(*cursor++);
     auto opKind = static_cast<CodeCompletionOperatorKind>(*cursor++);
-    auto context = static_cast<SemanticContextKind>(*cursor++);
     auto notRecommended =
-        static_cast<CodeCompletionResult::NotRecommendedReason>(*cursor++);
+        static_cast<ContextFreeNotRecommendedReason>(*cursor++);
     auto diagSeverity =
         static_cast<CodeCompletionDiagnosticSeverity>(*cursor++);
     auto isSystem = static_cast<bool>(*cursor++);
-    auto numBytesToErase = static_cast<unsigned>(*cursor++);
     auto chunkIndex = read32le(cursor);
     auto moduleIndex = read32le(cursor);
     auto briefDocIndex = read32le(cursor);
@@ -223,21 +222,20 @@ static bool readCachedModule(llvm::MemoryBuffer *in,
     auto briefDocComment = getString(briefDocIndex);
     auto diagMessage = getString(diagMessageIndex);
 
-    CodeCompletionResult *result = nullptr;
-    if (kind == CodeCompletionResult::ResultKind::Declaration) {
-      result = new (*V.Sink.Allocator) CodeCompletionResult(
-          context, CodeCompletionFlair(), numBytesToErase, string, declKind,
-          isSystem, moduleName, notRecommended, diagSeverity, diagMessage,
-          briefDocComment,
-          copyArray(*V.Sink.Allocator, ArrayRef<StringRef>(assocUSRs)),
-          CodeCompletionResult::ExpectedTypeRelation::Unknown, opKind);
+    ContextFreeCodeCompletionResult *result = nullptr;
+    if (kind == CodeCompletionResultKind::Declaration) {
+      result = new (*V.Allocator) ContextFreeCodeCompletionResult(
+          CodeCompletionResultKind::Declaration, static_cast<uint8_t>(declKind),
+          opKind, isSystem, string, moduleName, briefDocComment,
+          copyArray(*V.Allocator, ArrayRef<StringRef>(assocUSRs)),
+          notRecommended, diagSeverity, diagMessage);
     } else {
-      result = new (*V.Sink.Allocator) CodeCompletionResult(
-          kind, context, CodeCompletionFlair(), numBytesToErase, string,
-          CodeCompletionResult::ExpectedTypeRelation::NotApplicable, opKind);
+      result = new (*V.Allocator) ContextFreeCodeCompletionResult(
+          kind, string, opKind, /*BriefDocComment=*/"", notRecommended,
+          diagSeverity, diagMessage);
     }
 
-    V.Sink.Results.push_back(result);
+    V.Results.push_back(result);
   }
 
   return true;
@@ -342,27 +340,22 @@ static void writeCachedModule(llvm::raw_ostream &out,
   // RESULTS
   {
     endian::Writer LE(results, little);
-    for (CodeCompletionResult *R : V.Sink.Results) {
-      assert(!R->getFlair().toRaw() && "Any flairs should not be cached");
-      assert(R->getNotRecommendedReason() !=
-             CodeCompletionResult::NotRecommendedReason::InvalidAsyncContext &&
-             "InvalidAsyncContext is decl context specific, cannot be cached");
-
+    for (ContextFreeCodeCompletionResult *R : V.Results) {
       // FIXME: compress bitfield
       LE.write(static_cast<uint8_t>(R->getKind()));
-      if (R->getKind() == CodeCompletionResult::ResultKind::Declaration)
+      if (R->getKind() == CodeCompletionResultKind::Declaration) {
         LE.write(static_cast<uint8_t>(R->getAssociatedDeclKind()));
-      else
+      } else {
         LE.write(static_cast<uint8_t>(~0u));
-      if (R->isOperator())
-        LE.write(static_cast<uint8_t>(R->getOperatorKind()));
-      else
+      }
+      if (R->isOperator()) {
+        LE.write(static_cast<uint8_t>(R->getKnownOperatorKind()));
+      } else {
         LE.write(static_cast<uint8_t>(CodeCompletionOperatorKind::None));
-      LE.write(static_cast<uint8_t>(R->getSemanticContext()));
+      }
       LE.write(static_cast<uint8_t>(R->getNotRecommendedReason()));
       LE.write(static_cast<uint8_t>(R->getDiagnosticSeverity()));
       LE.write(static_cast<uint8_t>(R->isSystem()));
-      LE.write(static_cast<uint8_t>(R->getNumBytesToErase()));
       LE.write(
           static_cast<uint32_t>(addCompletionString(R->getCompletionString())));
       LE.write(addString(R->getModuleName()));      // index into strings

lib/IDE/CodeCompletion.cpp

@@ -144,37 +144,44 @@ bool CodeCompletionDiagnostics::getDiagnosticForDeprecated(
 
 } // namespace
 
-bool swift::ide::getCompletionDiagnostics(
-    CodeCompletionResult::NotRecommendedReason reason, const ValueDecl *D,
-    CodeCompletionDiagnosticSeverity &severity, llvm::raw_ostream &Out) {
-  using NotRecommendedReason = CodeCompletionResult::NotRecommendedReason;
-
-  ASTContext &ctx = D->getASTContext();
-
-  CodeCompletionDiagnostics Diag(ctx);
-  switch (reason) {
-  case NotRecommendedReason::Deprecated:
-  case NotRecommendedReason::SoftDeprecated:
-    return Diag.getDiagnosticForDeprecated(D, severity, Out);
-  case NotRecommendedReason::InvalidAsyncContext:
-    // FIXME: Could we use 'diag::async_in_nonasync_function'?
-    return Diag.getDiagnostics(severity, Out, diag::ide_async_in_nonasync_context,
-                        D->getName());
-  case NotRecommendedReason::CrossActorReference:
-    return Diag.getDiagnostics(severity, Out, diag::ide_cross_actor_reference_swift5,
-                        D->getName());
-  case NotRecommendedReason::RedundantImport:
-    return Diag.getDiagnostics(severity, Out, diag::ide_redundant_import,
-                        D->getName());
-  case NotRecommendedReason::RedundantImportIndirect:
-    return Diag.getDiagnostics(severity, Out, diag::ide_redundant_import_indirect,
-                        D->getName());
-  case NotRecommendedReason::VariableUsedInOwnDefinition:
-    return Diag.getDiagnostics(severity, Out, diag::recursive_accessor_reference,
-                        D->getName().getBaseIdentifier(), /*"getter"*/ 0);
-  case NotRecommendedReason::None:
+bool swift::ide::getContextFreeCompletionDiagnostics(
+    ContextFreeNotRecommendedReason Reason, const ValueDecl *D,
+    CodeCompletionDiagnosticSeverity &Severity, llvm::raw_ostream &Out) {
+  CodeCompletionDiagnostics Diag(D->getASTContext());
+  switch (Reason) {
+  case ContextFreeNotRecommendedReason::Deprecated:
+  case ContextFreeNotRecommendedReason::SoftDeprecated:
+    return Diag.getDiagnosticForDeprecated(D, Severity, Out);
+  case ContextFreeNotRecommendedReason::None:
     llvm_unreachable("invalid not recommended reason");
   }
   return true;
 }
 
+bool swift::ide::getContextualCompletionDiagnostics(
+    ContextualNotRecommendedReason Reason, const ValueDecl *D,
+    CodeCompletionDiagnosticSeverity &Severity, llvm::raw_ostream &Out) {
+  CodeCompletionDiagnostics Diag(D->getASTContext());
+  switch (Reason) {
+  case ContextualNotRecommendedReason::InvalidAsyncContext:
+    // FIXME: Could we use 'diag::async_in_nonasync_function'?
+    return Diag.getDiagnostics(
+        Severity, Out, diag::ide_async_in_nonasync_context, D->getName());
+  case ContextualNotRecommendedReason::CrossActorReference:
+    return Diag.getDiagnostics(
+        Severity, Out, diag::ide_cross_actor_reference_swift5, D->getName());
+  case ContextualNotRecommendedReason::RedundantImport:
+    return Diag.getDiagnostics(Severity, Out, diag::ide_redundant_import,
+                               D->getName());
+  case ContextualNotRecommendedReason::RedundantImportIndirect:
+    return Diag.getDiagnostics(
+        Severity, Out, diag::ide_redundant_import_indirect, D->getName());
+  case ContextualNotRecommendedReason::VariableUsedInOwnDefinition:
+    return Diag.getDiagnostics(
+        Severity, Out, diag::recursive_accessor_reference,
+        D->getName().getBaseIdentifier(), /*"getter"*/ 0);
+  case ContextualNotRecommendedReason::None:
+    llvm_unreachable("invalid not recommended reason");
+  }
+  return true;
+}

lib/IDE/CodeCompletionCache.cpp

@@ -21,12 +21,21 @@ class ValueDecl;
 
 namespace ide {
 
-/// Populate \p severity and \p Out with the diagnostics for \p D.
+/// Populate \p severity and \p Out with the context-free diagnostics for \p D.
+/// See \c NotRecommendedReason for an explaination of context-free vs.
+/// contextual diagnostics.
 /// Returns \c true if it fails to generate the diagnostics.
-bool getCompletionDiagnostics(CodeCompletionResult::NotRecommendedReason reason,
-                              const ValueDecl *D,
-                              CodeCompletionDiagnosticSeverity &severity,
-                              llvm::raw_ostream &Out);
+bool getContextFreeCompletionDiagnostics(
+    ContextFreeNotRecommendedReason reason, const ValueDecl *D,
+    CodeCompletionDiagnosticSeverity &severity, llvm::raw_ostream &Out);
+
+/// Populate \p severity and \p Out with the contextual diagnostics for \p D.
+/// See \c NotRecommendedReason for an explaination of context-free vs.
+/// contextual diagnostics.
+/// Returns \c true if it fails to generate the diagnostics.
+bool getContextualCompletionDiagnostics(
+    ContextualNotRecommendedReason reason, const ValueDecl *D,
+    CodeCompletionDiagnosticSeverity &severity, llvm::raw_ostream &Out);
 
 } // namespace ide
 } // namespace swift

lib/IDE/CodeCompletionDiagnostics.cpp

@@ -74,7 +74,7 @@ class CodeCompletionResultBuilder {
   friend CodeCompletionStringPrinter;
 
   CodeCompletionResultSink &Sink;
-  CodeCompletionResult::ResultKind Kind;
+  CodeCompletionResultKind Kind;
   SemanticContextKind SemanticContext;
   CodeCompletionFlair Flair;
   unsigned NumBytesToErase = 0;
@@ -89,8 +89,10 @@ class CodeCompletionResultBuilder {
   CodeCompletionResult::ExpectedTypeRelation ExpectedTypeRelation =
       CodeCompletionResult::ExpectedTypeRelation::Unknown;
   bool Cancelled = false;
-  CodeCompletionResult::NotRecommendedReason NotRecReason =
-      CodeCompletionResult::NotRecommendedReason::None;
+  ContextFreeNotRecommendedReason ContextFreeNotRecReason =
+      ContextFreeNotRecommendedReason::None;
+  ContextualNotRecommendedReason ContextualNotRecReason =
+      ContextualNotRecommendedReason::None;
   StringRef BriefDocComment;
 
   void addChunkWithText(CodeCompletionString::Chunk::ChunkKind Kind,
@@ -117,7 +119,7 @@ class CodeCompletionResultBuilder {
 
 public:
   CodeCompletionResultBuilder(CodeCompletionResultSink &Sink,
-                              CodeCompletionResult::ResultKind Kind,
+                              CodeCompletionResultKind Kind,
                               SemanticContextKind SemanticContext,
                               const ExpectedTypeContext &declTypeContext)
       : Sink(Sink), Kind(Kind), SemanticContext(SemanticContext),
@@ -146,12 +148,11 @@ class CodeCompletionResultBuilder {
 
   void setLiteralKind(CodeCompletionLiteralKind kind) { LiteralKind = kind; }
   void setKeywordKind(CodeCompletionKeywordKind kind) { KeywordKind = kind; }
-  void setNotRecommended(CodeCompletionResult::NotRecommendedReason Reason) {
-    NotRecReason = Reason;
+  void setContextFreeNotRecommended(ContextFreeNotRecommendedReason Reason) {
+    ContextFreeNotRecReason = Reason;
   }
-
-  void setSemanticContext(SemanticContextKind Kind) {
-    SemanticContext = Kind;
+  void setContextualNotRecommended(ContextualNotRecommendedReason Reason) {
+    ContextualNotRecReason = Reason;
   }
 
   void addFlair(CodeCompletionFlair Options) {

lib/IDE/CodeCompletionDiagnostics.h

@@ -121,7 +121,7 @@ static void toDisplayString(CodeCompletionResult *Result,
     }
     if (C.is(CodeCompletionString::Chunk::ChunkKind::TypeAnnotation) ||
         C.is(CodeCompletionString::Chunk::ChunkKind::TypeAnnotationBegin)) {
-      if (Result->getKind() == CodeCompletionResult::ResultKind::Declaration) {
+      if (Result->getKind() == CodeCompletionResultKind::Declaration) {
         switch (Result->getAssociatedDeclKind()) {
         case CodeCompletionDeclKind::Module:
         case CodeCompletionDeclKind::PrecedenceGroup: