[CodeComplete] Compute type relations for global cached results

Computing the type relation for every item in the code completion cache is way to expensive (~4x slowdown for global completion that imports `SwiftUI`). Instead, compute a type’s supertypes (protocol conformances and superclasses) once and write their USRs to the cache. To compute a type relation we can then check if the contextual type is in the completion item’s supertypes.

This reduces the overhead of computing the type relations (again global completion that imports `SwiftUI`) to ~6% – measured by instructions executed.

Technically, we might miss some conversions like
- retroactive conformances inside another module (because we can’t cache them if that other module isn’t imported)
- complex generic conversions (just too complicated to model using USRs)

Because of this, we never report an `unrelated` type relation for global items but always default to `unknown`.

But I believe this change covers the most common cases and is a good tradeoff between accuracy and performance.

rdar://83846531

Author: ahoppen

Diff for: include/swift/IDE/CodeCompletion.h

@@ -63,7 +63,7 @@ bool isDynamicLookup(Type T);
 
 void postProcessCompletionResults(
     MutableArrayRef<CodeCompletionResult *> results, CompletionKind Kind,
-    DeclContext *DC, CodeCompletionResultSink *Sink);
+    const DeclContext *DC, CodeCompletionResultSink *Sink);
 
 void deliverCompletionResults(CodeCompletionContext &CompletionContext,
                               CompletionLookup &Lookup, DeclContext *DC,

Diff for: include/swift/IDE/CodeCompletionCache.h

@@ -70,6 +70,10 @@ class CodeCompletionCache {
 
     std::vector<const ContextFreeCodeCompletionResult *> Results;
 
+    /// The arena that contains the \c USRBasedTypes of the
+    /// \c ContextFreeCodeCompletionResult in this cache value.
+    USRBasedTypeArena USRTypeArena;
+
     Value() : Allocator(std::make_shared<llvm::BumpPtrAllocator>()) {}
   };
   using ValueRefCntPtr = llvm::IntrusiveRefCntPtr<Value>;

Diff for: include/swift/IDE/CodeCompletionConsumer.h

@@ -29,7 +29,8 @@ class CodeCompletionConsumer {
   virtual void
   handleResultsAndModules(CodeCompletionContext &context,
                           ArrayRef<RequestedCachedModule> requestedModules,
-                          DeclContext *DC) = 0;
+                          const ExpectedTypeContext *TypeContext,
+                          const DeclContext *DC) = 0;
 };
 
 /// A simplified code completion consumer interface that clients can use to get
@@ -40,7 +41,8 @@ struct SimpleCachingCodeCompletionConsumer : public CodeCompletionConsumer {
   // Implement the CodeCompletionConsumer interface.
   void handleResultsAndModules(CodeCompletionContext &context,
                                ArrayRef<RequestedCachedModule> requestedModules,
-                               DeclContext *DCForModules) override;
+                               const ExpectedTypeContext *TypeContext,
+                               const DeclContext *DCForModules) override;
 
   /// Clients should override this method to receive \p Results.
   virtual void handleResults(CodeCompletionContext &context) = 0;

Diff for: include/swift/IDE/CodeCompletionResult.h

@@ -390,7 +390,7 @@ class ContextFreeCodeCompletionResult {
   /// StringRefs outlive this result, typically by storing them in the same
   /// \c CodeCompletionResultSink as the result itself.
   static ContextFreeCodeCompletionResult *createPatternOrBuiltInOperatorResult(
-      llvm::BumpPtrAllocator &Allocator, CodeCompletionResultKind Kind,
+      CodeCompletionResultSink &Sink, CodeCompletionResultKind Kind,
       CodeCompletionString *CompletionString,
       CodeCompletionOperatorKind KnownOperatorKind,
       NullTerminatedStringRef BriefDocComment,
@@ -405,7 +405,7 @@ class ContextFreeCodeCompletionResult {
   /// \p BriefDocComment outlive this result, typically by storing them in
   /// the same \c CodeCompletionResultSink as the result itself.
   static ContextFreeCodeCompletionResult *
-  createKeywordResult(llvm::BumpPtrAllocator &Allocator,
+  createKeywordResult(CodeCompletionResultSink &Sink,
                       CodeCompletionKeywordKind Kind,
                       CodeCompletionString *CompletionString,
                       NullTerminatedStringRef BriefDocComment,
@@ -417,7 +417,7 @@ class ContextFreeCodeCompletionResult {
   /// result, typically by storing them in the same \c CodeCompletionResultSink
   /// as the result itself.
   static ContextFreeCodeCompletionResult *
-  createLiteralResult(llvm::BumpPtrAllocator &Allocator,
+  createLiteralResult(CodeCompletionResultSink &Sink,
                       CodeCompletionLiteralKind LiteralKind,
                       CodeCompletionString *CompletionString,
                       CodeCompletionResultType ResultType);
@@ -428,7 +428,7 @@ class ContextFreeCodeCompletionResult {
   /// \c StringRefs outlive this result, typically by storing them in the same
   /// \c CodeCompletionResultSink as the result itself.
   static ContextFreeCodeCompletionResult *createDeclResult(
-      llvm::BumpPtrAllocator &Allocator, CodeCompletionString *CompletionString,
+      CodeCompletionResultSink &Sink, CodeCompletionString *CompletionString,
       const Decl *AssociatedDecl, NullTerminatedStringRef ModuleName,
       NullTerminatedStringRef BriefDocComment,
       ArrayRef<NullTerminatedStringRef> AssociatedUSRs,
@@ -566,6 +566,8 @@ class CodeCompletionResult {
   /// information.
   /// This computes the type relation between the completion item and its
   /// expected type context.
+  /// See \c CodeCompletionResultType::calculateTypeRelation for documentation
+  /// on \p USRTypeContext.
   /// The \c ContextFree result must outlive this result. Typically, this is
   /// done by allocating the two in the same sink or adopting the context free
   /// sink in the sink that allocates this result.
@@ -574,6 +576,7 @@ class CodeCompletionResult {
                        CodeCompletionFlair Flair, uint8_t NumBytesToErase,
                        const ExpectedTypeContext *TypeContext,
                        const DeclContext *DC,
+                       const USRBasedTypeContext *USRTypeContext,
                        ContextualNotRecommendedReason NotRecommended,
                        CodeCompletionDiagnosticSeverity DiagnosticSeverity,
                        NullTerminatedStringRef DiagnosticMessage);

Diff for: include/swift/IDE/CodeCompletionResultSink.h

@@ -44,6 +44,14 @@ struct CodeCompletionResultSink {
   /// Whether to include an item without any default arguments.
   bool addCallWithNoDefaultArgs = true;
 
+private:
+  /// Whether the code completion results computed for this sink are intended to
+  /// only be stored in the cache. In this case no contextual information is
+  /// computed and all types in \c ContextFreeCodeCompletionResult should be
+  /// USR-based instead of AST-based.
+  USRBasedTypeArena *USRTypeArena = nullptr;
+
+public:
   std::vector<CodeCompletionResult *> Results;
 
   /// A single-element cache for module names stored in Allocator, keyed by a
@@ -52,6 +60,30 @@ struct CodeCompletionResultSink {
 
   CodeCompletionResultSink()
       : Allocator(std::make_shared<llvm::BumpPtrAllocator>()) {}
+
+  llvm::BumpPtrAllocator &getAllocator() { return *Allocator; }
+
+  /// Marks the sink as producing results for the code completion cache.
+  /// In this case the produced results will not contain any contextual
+  /// information and all types in the \c ContextFreeCodeCompletionResult are
+  /// USR-based.
+  void setProduceContextFreeResults(USRBasedTypeArena &USRTypeArena) {
+    this->USRTypeArena = &USRTypeArena;
+  }
+
+  /// See \c setProduceContextFreeResults.
+  bool shouldProduceContextFreeResults() const {
+    return USRTypeArena != nullptr;
+  }
+
+  /// If \c shouldProduceContextFreeResults is \c true, returns the arena in
+  /// which the USR-based types of the \c ContextFreeCodeCompletionResult should
+  /// be stored.
+  USRBasedTypeArena &getUSRTypeArena() const {
+    assert(USRTypeArena != nullptr &&
+           "Must only be called if shouldProduceContextFreeResults is true");
+    return *USRTypeArena;
+  }
 };
 
 } // end namespace ide