Merge pull request #58999 from ahoppen/pr/cache-function-asyncness

[CodeCompletion] Cache 'async'-ness of free functions

Author: ahoppen

include/swift/AST/DiagnosticsIDE.def

@@ -17,21 +17,21 @@
 
 ERROR(ide_async_in_nonasync_context, none,
       "async %0 used in a context that does not support concurrency",
-      (DeclName))
+      (StringRef))
 
 // NOTE: This is WARNING because this is emitted for cross actor references with
 // non-'Sendable' types. That is optionally ('-warn-concurrency') warning in
 // Swift 5.5.
 WARNING(ide_cross_actor_reference_swift5, none,
         "actor-isolated %0 should only be referenced from inside the actor",
-        (DeclName))
+        (StringRef))
 
 WARNING(ide_redundant_import, none,
-        "module %0 is already imported", (DeclName))
+        "module %0 is already imported", (StringRef))
 
 // FIXME: Inform which other 'import' this module came from.
 NOTE(ide_redundant_import_indirect, none,
-     "module %0 is already imported via another module import", (DeclName))
+     "module %0 is already imported via another module import", (StringRef))
 
 WARNING(ide_availability_softdeprecated, Deprecation,
         "%select{getter for |setter for |}0%1 will be deprecated"
@@ -46,6 +46,10 @@ WARNING(ide_availability_softdeprecated_rename, Deprecation,
         ": renamed to '%6'",
         (unsigned, DeclName, bool, StringRef, bool, llvm::VersionTuple, StringRef))
 
+WARNING(ide_recursive_accessor_reference,none,
+        "attempting to %select{access|modify}1 %0 within its own "
+        "%select{getter|setter}1", (StringRef, bool))
+
 //===----------------------------------------------------------------------===//
 
 #define UNDEFINE_DIAGNOSTIC_MACROS

include/swift/IDE/CodeCompletionConsumer.h

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

include/swift/IDE/CodeCompletionResult.h

@@ -329,6 +329,7 @@ class ContextFreeCodeCompletionResult {
   static_assert(int(CodeCompletionOperatorKind::MAX_VALUE) < 1 << 6, "");
 
   bool IsSystem : 1;
+  bool IsAsync : 1;
   CodeCompletionString *CompletionString;
   NullTerminatedStringRef ModuleName;
   NullTerminatedStringRef BriefDocComment;
@@ -344,6 +345,10 @@ class ContextFreeCodeCompletionResult {
   NullTerminatedStringRef DiagnosticMessage;
   NullTerminatedStringRef FilterName;
 
+  /// If the result represents a \c ValueDecl the name by which this decl should
+  /// be refered to in diagnostics.
+  NullTerminatedStringRef NameForDiagnostics;
+
 public:
   /// Memberwise initializer. \p AssociatedKInd is opaque and will be
   /// interpreted based on \p Kind. If \p KnownOperatorKind is \c None and the
@@ -355,7 +360,7 @@ class ContextFreeCodeCompletionResult {
   /// \c CodeCompletionResultSink as the result itself.
   ContextFreeCodeCompletionResult(
       CodeCompletionResultKind Kind, uint8_t AssociatedKind,
-      CodeCompletionOperatorKind KnownOperatorKind, bool IsSystem,
+      CodeCompletionOperatorKind KnownOperatorKind, bool IsSystem, bool IsAsync,
       CodeCompletionString *CompletionString,
       NullTerminatedStringRef ModuleName,
       NullTerminatedStringRef BriefDocComment,
@@ -364,13 +369,15 @@ class ContextFreeCodeCompletionResult {
       ContextFreeNotRecommendedReason NotRecommended,
       CodeCompletionDiagnosticSeverity DiagnosticSeverity,
       NullTerminatedStringRef DiagnosticMessage,
-      NullTerminatedStringRef FilterName)
+      NullTerminatedStringRef FilterName,
+      NullTerminatedStringRef NameForDiagnostics)
       : Kind(Kind), KnownOperatorKind(KnownOperatorKind), IsSystem(IsSystem),
-        CompletionString(CompletionString), ModuleName(ModuleName),
-        BriefDocComment(BriefDocComment), AssociatedUSRs(AssociatedUSRs),
-        ResultType(ResultType), NotRecommended(NotRecommended),
-        DiagnosticSeverity(DiagnosticSeverity),
-        DiagnosticMessage(DiagnosticMessage), FilterName(FilterName) {
+        IsAsync(IsAsync), CompletionString(CompletionString),
+        ModuleName(ModuleName), BriefDocComment(BriefDocComment),
+        AssociatedUSRs(AssociatedUSRs), ResultType(ResultType),
+        NotRecommended(NotRecommended), DiagnosticSeverity(DiagnosticSeverity),
+        DiagnosticMessage(DiagnosticMessage), FilterName(FilterName),
+        NameForDiagnostics(NameForDiagnostics) {
     this->AssociatedKind.Opaque = AssociatedKind;
     assert((NotRecommended == ContextFreeNotRecommendedReason::None) ==
                (DiagnosticSeverity == CodeCompletionDiagnosticSeverity::None) &&
@@ -396,7 +403,7 @@ class ContextFreeCodeCompletionResult {
   static ContextFreeCodeCompletionResult *createPatternOrBuiltInOperatorResult(
       CodeCompletionResultSink &Sink, CodeCompletionResultKind Kind,
       CodeCompletionString *CompletionString,
-      CodeCompletionOperatorKind KnownOperatorKind,
+      CodeCompletionOperatorKind KnownOperatorKind, bool IsAsync,
       NullTerminatedStringRef BriefDocComment,
       CodeCompletionResultType ResultType,
       ContextFreeNotRecommendedReason NotRecommended,
@@ -431,15 +438,17 @@ class ContextFreeCodeCompletionResult {
   /// \note The caller must ensure that the \p CompletionString and all
   /// \c StringRefs outlive this result, typically by storing them in the same
   /// \c CodeCompletionResultSink as the result itself.
-  static ContextFreeCodeCompletionResult *createDeclResult(
-      CodeCompletionResultSink &Sink, CodeCompletionString *CompletionString,
-      const Decl *AssociatedDecl, NullTerminatedStringRef ModuleName,
-      NullTerminatedStringRef BriefDocComment,
-      ArrayRef<NullTerminatedStringRef> AssociatedUSRs,
-      CodeCompletionResultType ResultType,
-      ContextFreeNotRecommendedReason NotRecommended,
-      CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-      NullTerminatedStringRef DiagnosticMessage);
+  static ContextFreeCodeCompletionResult *
+  createDeclResult(CodeCompletionResultSink &Sink,
+                   CodeCompletionString *CompletionString,
+                   const Decl *AssociatedDecl, bool IsAsync,
+                   NullTerminatedStringRef ModuleName,
+                   NullTerminatedStringRef BriefDocComment,
+                   ArrayRef<NullTerminatedStringRef> AssociatedUSRs,
+                   CodeCompletionResultType ResultType,
+                   ContextFreeNotRecommendedReason NotRecommended,
+                   CodeCompletionDiagnosticSeverity DiagnosticSeverity,
+                   NullTerminatedStringRef DiagnosticMessage);
 
   CodeCompletionResultKind getKind() const { return Kind; }
 
@@ -469,6 +478,8 @@ class ContextFreeCodeCompletionResult {
 
   bool isSystem() const { return IsSystem; };
 
+  bool isAsync() const { return IsAsync; };
+
   CodeCompletionString *getCompletionString() const { return CompletionString; }
 
   NullTerminatedStringRef getModuleName() const { return ModuleName; }
@@ -494,6 +505,10 @@ class ContextFreeCodeCompletionResult {
 
   NullTerminatedStringRef getFilterName() const { return FilterName; }
 
+  NullTerminatedStringRef getNameForDiagnostics() const {
+    return NameForDiagnostics;
+  }
+
   bool isOperator() const {
     if (getKind() == CodeCompletionResultKind::Declaration) {
       switch (getAssociatedDeclKind()) {
@@ -531,11 +546,6 @@ class CodeCompletionResult {
   ContextualNotRecommendedReason NotRecommended : 4;
   static_assert(int(ContextualNotRecommendedReason::MAX_VALUE) < 1 << 4, "");
 
-  CodeCompletionDiagnosticSeverity DiagnosticSeverity : 3;
-  static_assert(int(CodeCompletionDiagnosticSeverity::MAX_VALUE) < 1 << 3, "");
-
-  NullTerminatedStringRef DiagnosticMessage;
-
   /// The number of bytes to the left of the code completion point that
   /// should be erased first if this completion string is inserted in the
   /// editor buffer.
@@ -556,14 +566,10 @@ class CodeCompletionResult {
                        SemanticContextKind SemanticContext,
                        CodeCompletionFlair Flair, uint8_t NumBytesToErase,
                        CodeCompletionResultTypeRelation TypeDistance,
-                       ContextualNotRecommendedReason NotRecommended,
-                       CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-                       NullTerminatedStringRef DiagnosticMessage)
+                       ContextualNotRecommendedReason NotRecommended)
       : ContextFree(ContextFree), SemanticContext(SemanticContext),
         Flair(Flair.toRaw()), NotRecommended(NotRecommended),
-        DiagnosticSeverity(DiagnosticSeverity),
-        DiagnosticMessage(DiagnosticMessage), NumBytesToErase(NumBytesToErase),
-        TypeDistance(TypeDistance) {}
+        NumBytesToErase(NumBytesToErase), TypeDistance(TypeDistance) {}
 
 public:
   /// Enrich a \c ContextFreeCodeCompletionResult with the following contextual
@@ -581,9 +587,8 @@ class CodeCompletionResult {
                        const ExpectedTypeContext *TypeContext,
                        const DeclContext *DC,
                        const USRBasedTypeContext *USRTypeContext,
-                       ContextualNotRecommendedReason NotRecommended,
-                       CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-                       NullTerminatedStringRef DiagnosticMessage);
+                       bool CanCurrDeclContextHandleAsync,
+                       ContextualNotRecommendedReason NotRecommended);
 
   const ContextFreeCodeCompletionResult &getContextFreeResult() const {
     return ContextFree;
@@ -702,37 +707,23 @@ class CodeCompletionResult {
     return getContextFreeResult().getAssociatedUSRs();
   }
 
-  /// Get the contextual diagnostic severity. This disregards context-free
-  /// diagnostics.
-  CodeCompletionDiagnosticSeverity getContextualDiagnosticSeverity() const {
-    return DiagnosticSeverity;
-  }
-
-  /// Get the contextual diagnostic message. This disregards context-free
-  /// diagnostics.
-  NullTerminatedStringRef getContextualDiagnosticMessage() const {
-    return DiagnosticMessage;
-  }
-
-  /// Return the contextual diagnostic severity if there was a contextual
-  /// diagnostic. If there is no contextual diagnostic, return the context-free
-  /// diagnostic severity.
-  CodeCompletionDiagnosticSeverity getDiagnosticSeverity() const {
-    if (NotRecommended != ContextualNotRecommendedReason::None) {
-      return DiagnosticSeverity;
-    } else {
-      return getContextFreeResult().getDiagnosticSeverity();
-    }
-  }
-
-  /// Return the contextual diagnostic message if there was a contextual
-  /// diagnostic. If there is no contextual diagnostic, return the context-free
-  /// diagnostic message.
-  NullTerminatedStringRef getDiagnosticMessage() const {
+  /// Get the contextual diagnostic severity and message. This disregards
+  /// context-free diagnostics.
+  std::pair<CodeCompletionDiagnosticSeverity, NullTerminatedStringRef>
+  getContextualDiagnosticSeverityAndMessage(SmallVectorImpl<char> &Scratch,
+                                            const ASTContext &Ctx) const;
+
+  /// Return the contextual diagnostic severity and message if there was a
+  /// contextual diagnostic. If there is no contextual diagnostic, return the
+  /// context-free diagnostic severity and message.
+  std::pair<CodeCompletionDiagnosticSeverity, NullTerminatedStringRef>
+  getDiagnosticSeverityAndMessage(SmallVectorImpl<char> &Scratch,
+                                  const ASTContext &Ctx) const {
     if (NotRecommended != ContextualNotRecommendedReason::None) {
-      return DiagnosticMessage;
+      return getContextualDiagnosticSeverityAndMessage(Scratch, Ctx);
     } else {
-      return getContextFreeResult().getDiagnosticMessage();
+      return std::make_pair(getContextFreeResult().getDiagnosticSeverity(),
+                            getContextFreeResult().getDiagnosticMessage());
     }
   }
 

include/swift/IDE/CompletionInstance.h

@@ -46,7 +46,7 @@ makeCodeCompletionMemoryBuffer(const llvm::MemoryBuffer *origBuf,
 /// The result returned via the callback from the perform*Operation methods.
 struct CompletionInstanceResult {
   /// The compiler instance that is prepared for the second pass.
-  CompilerInstance &CI;
+  std::shared_ptr<CompilerInstance> CI;
   /// Whether an AST was reused.
   bool DidReuseAST;
   /// Whether the CompletionInstance found a code completion token in the source
@@ -87,14 +87,14 @@ class CompletionInstance {
 
   std::mutex mtx;
 
-  std::unique_ptr<CompilerInstance> CachedCI;
+  std::shared_ptr<CompilerInstance> CachedCI;
   llvm::hash_code CachedArgHash;
   llvm::sys::TimePoint<> DependencyCheckedTimestamp;
   llvm::StringMap<llvm::hash_code> InMemoryDependencyHash;
   unsigned CachedReuseCount = 0;
   std::atomic<bool> CachedCIShouldBeInvalidated;
 
-  void cacheCompilerInstance(std::unique_ptr<CompilerInstance> CI,
+  void cacheCompilerInstance(std::shared_ptr<CompilerInstance> CI,
                              llvm::hash_code ArgsHash);
 
   bool shouldCheckDependencies() const;

include/swift/IDE/CompletionLookup.h

@@ -254,6 +254,10 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void setIdealExpectedType(Type Ty) { expectedTypeContext.setIdealType(Ty); }
 
+  bool canCurrDeclContextHandleAsync() const {
+    return CanCurrDeclContextHandleAsync;
+  }
+
   void setCanCurrDeclContextHandleAsync(bool CanCurrDeclContextHandleAsync) {
     this->CanCurrDeclContextHandleAsync = CanCurrDeclContextHandleAsync;
   }

include/swift/IDE/SwiftCompletionInfo.h

@@ -20,8 +20,7 @@ namespace swift {
 namespace ide {
 
 struct SwiftCompletionInfo {
-  swift::ASTContext *swiftASTContext = nullptr;
-  const swift::CompilerInvocation *invocation = nullptr;
+  std::shared_ptr<CompilerInstance> compilerInstance = nullptr;
   CodeCompletionContext *completionContext = nullptr;
 };
 

lib/IDE/CodeCompletion.cpp

@@ -1369,7 +1369,8 @@ void swift::ide::deliverCompletionResults(
                                /*Sink=*/nullptr);
 
   Consumer.handleResultsAndModules(CompletionContext, RequestedModules,
-                                   Lookup.getExpectedTypeContext(), DC);
+                                   Lookup.getExpectedTypeContext(), DC,
+                                   Lookup.canCurrDeclContextHandleAsync());
 }
 
 bool CodeCompletionCallbacksImpl::trySolverCompletion(bool MaybeFuncBody) {

lib/IDE/CodeCompletionCache.cpp

@@ -103,7 +103,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 = 7; // Store whether a type can be used as attribute
+static constexpr uint32_t onDiskCompletionCacheVersion =
+    9; // Store whether a decl is async
 
 /// Deserializes CodeCompletionResults from \p in and stores them in \p V.
 /// \see writeCacheModule.
@@ -234,11 +235,13 @@ static bool readCachedModule(llvm::MemoryBuffer *in,
     auto diagSeverity =
         static_cast<CodeCompletionDiagnosticSeverity>(*cursor++);
     auto isSystem = static_cast<bool>(*cursor++);
+    auto isAsync = static_cast<bool>(*cursor++);
     auto chunkIndex = read32le(cursor);
     auto moduleIndex = read32le(cursor);
     auto briefDocIndex = read32le(cursor);
     auto diagMessageIndex = read32le(cursor);
     auto filterNameIndex = read32le(cursor);
+    auto nameForDiagnosticsIndex = read32le(cursor);
 
     auto assocUSRCount = read32le(cursor);
     SmallVector<NullTerminatedStringRef, 4> assocUSRs;
@@ -258,13 +261,14 @@ static bool readCachedModule(llvm::MemoryBuffer *in,
     auto briefDocComment = getString(briefDocIndex);
     auto diagMessage = getString(diagMessageIndex);
     auto filterName = getString(filterNameIndex);
+    auto nameForDiagnostics = getString(nameForDiagnosticsIndex);
 
     ContextFreeCodeCompletionResult *result =
         new (*V.Allocator) ContextFreeCodeCompletionResult(
-            kind, associatedKind, opKind, isSystem, string, moduleName,
+            kind, associatedKind, opKind, isSystem, isAsync, string, moduleName,
             briefDocComment, makeArrayRef(assocUSRs).copy(*V.Allocator),
             CodeCompletionResultType(resultTypes), notRecommended, diagSeverity,
-            diagMessage, filterName);
+            diagMessage, filterName, nameForDiagnostics);
 
     V.Results.push_back(result);
   }
@@ -420,12 +424,14 @@ static void writeCachedModule(llvm::raw_ostream &out,
       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->isAsync()));
       LE.write(
           static_cast<uint32_t>(addCompletionString(R->getCompletionString())));
       LE.write(addString(R->getModuleName()));      // index into strings
       LE.write(addString(R->getBriefDocComment())); // index into strings
       LE.write(addString(R->getDiagnosticMessage())); // index into strings
       LE.write(addString(R->getFilterName())); // index into strings
+      LE.write(addString(R->getNameForDiagnostics())); // index into strings
 
       LE.write(static_cast<uint32_t>(R->getAssociatedUSRs().size()));
       for (unsigned i = 0; i < R->getAssociatedUSRs().size(); ++i) {