Merge pull request #68075 from ahoppen/ahoppen/labeled-trailing-closure-solver-based

[CodeCompletion] Migrate labeled trailing closure completions to solver-based

Author: ahoppen

include/swift/IDE/AfterPoundExprCompletion.h

@@ -47,8 +47,7 @@ class AfterPoundExprCompletion : public TypeCheckCompletionCallback {
       : CompletionExpr(CompletionExpr), DC(DC), ParentStmtKind(ParentStmtKind) {
   }
 
-  void deliverResults(ide::CodeCompletionContext &CompletionCtx,
-                      CodeCompletionConsumer &Consumer);
+  void collectResults(ide::CodeCompletionContext &CompletionCtx);
 };
 
 } // end namespace ide

include/swift/IDE/ArgumentCompletion.h

@@ -25,31 +25,48 @@ class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
   struct Result {
     /// The type associated with the code completion expression itself.
     Type ExpectedType;
+
     /// The expected return type of the function call.
     Type ExpectedCallType;
+
     /// True if this is a subscript rather than a function call.
     bool IsSubscript;
+
     /// The FuncDecl or SubscriptDecl associated with the call.
     ValueDecl *FuncD;
+
     /// The type of the function being called.
     AnyFunctionType *FuncTy;
+
     /// The index of the argument containing the completion location
     unsigned ArgIdx;
+
     /// The index of the parameter corresponding to the completion argument.
     llvm::Optional<unsigned> ParamIdx;
+
     /// The indices of all params that were bound to non-synthesized
     /// arguments. Used so we don't suggest them even when the args are out of
     /// order.
     std::set<unsigned> ClaimedParamIndices;
+
     /// True if the completion is a noninitial term in a variadic argument.
     bool IsNoninitialVariadic;
+
     /// The base type of the call/subscript (null for free functions).
     Type BaseType;
+
     /// True if an argument label precedes the completion location.
     bool HasLabel;
+
+    /// The argument index of the first trailing closure.
+    ///
+    /// \c None if the call doesn't have a trailing closure.
+    llvm::Optional<unsigned> FirstTrailingClosureIndex;
+
     /// Whether the surrounding context is async and thus calling async
     /// functions is supported.
     bool IsInAsyncContext;
+
     /// A bitfield to mark whether the parameter at a given index is optional.
     /// Parameters can be optional if they have a default argument or belong to
     /// a parameter pack.
@@ -93,9 +110,12 @@ class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
   /// function signature instead of suggesting individual labels. Used when
   /// completing after the opening '(' of a function call \param Loc The
   /// location of the code completion token
-  void deliverResults(bool IncludeSignature, SourceLoc Loc, DeclContext *DC,
-                      CodeCompletionContext &CompletionCtx,
-                      CodeCompletionConsumer &Consumer);
+  /// \param IsLabeledTrailingClosure Whether we are completing the label of a
+  /// labeled trailing closure, ie. if the code completion location is outside
+  /// the call after the first trailing closure of the call.
+  void collectResults(bool IncludeSignature, bool IsLabeledTrailingClosure,
+                      SourceLoc Loc, DeclContext *DC,
+                      CodeCompletionContext &CompletionCtx);
 };
 
 } // end namespace ide

include/swift/IDE/CodeCompletion.h

@@ -65,9 +65,10 @@ void postProcessCompletionResults(
     MutableArrayRef<CodeCompletionResult *> results, CompletionKind Kind,
     const DeclContext *DC, CodeCompletionResultSink *Sink);
 
-void deliverCompletionResults(CodeCompletionContext &CompletionContext,
+void collectCompletionResults(CodeCompletionContext &CompletionContext,
                               CompletionLookup &Lookup, DeclContext *DC,
-                              CodeCompletionConsumer &Consumer);
+                              const ExpectedTypeContext &TypeContext,
+                              bool CanCurrDeclContextHandleAsync);
 
 /// Create a factory for code completion callbacks.
 IDEInspectionCallbacksFactory *

include/swift/IDE/CodeCompletionConsumer.h

@@ -22,30 +22,9 @@ 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,
-                          const ExpectedTypeContext *TypeContext,
-                          const DeclContext *DC,
-                          bool CanCurrDeclContextHandleAsync) = 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,
-                               const ExpectedTypeContext *TypeContext,
-                               const DeclContext *DCForModules,
-                               bool CanCurrDeclContextHandleAsync) override;
-
   /// Clients should override this method to receive \p Results.
   virtual void handleResults(CodeCompletionContext &context) = 0;
 };

include/swift/IDE/CodeCompletionContext.h

@@ -20,6 +20,7 @@ namespace swift {
 namespace ide {
 
 class CodeCompletionCache;
+struct RequestedCachedModule;
 
 class CodeCompletionContext {
   friend class CodeCompletionResultBuilder;
@@ -103,6 +104,13 @@ class CodeCompletionContext {
   sortCompletionResults(ArrayRef<CodeCompletionResult *> Results);
 
   CodeCompletionResultSink &getResultSink() { return CurrentResults; }
+
+  /// Add code completion results from the given requested modules to this
+  /// context.
+  void addResultsFromModules(ArrayRef<RequestedCachedModule> RequestedModules,
+                             const ExpectedTypeContext &TypeContext,
+                             const DeclContext *DC,
+                             bool CanCurrDeclContextHandleAsync);
 };
 
 } // end namespace ide

include/swift/IDE/CodeCompletionResult.h

@@ -211,7 +211,6 @@ enum class CompletionKind : uint8_t {
   EffectsSpecifier,
   PoundAvailablePlatform,
   CallArg,
-  LabeledTrailingClosure,
   ReturnStmtExpr,
   ThenStmtExpr,
   YieldStmtExpr,

include/swift/IDE/CodeCompletionResultType.h

@@ -74,6 +74,23 @@ class ExpectedTypeContext {
     }
   }
 
+  /// Form a union of this expected type context with \p Other.
+  ///
+  /// Any possible type from either type context will be considered a possible
+  /// type in the merged type context.
+  void merge(const ExpectedTypeContext &Other) {
+    PossibleTypes.append(Other.PossibleTypes);
+
+    // We can't merge ideal types. If they are different, setting to a null type
+    // is the best thing we can do.
+    if (!IdealType || !Other.IdealType || !IdealType->isEqual(Other.IdealType)) {
+      IdealType = Type();
+    }
+    IsImplicitSingleExpressionReturn |= Other.IsImplicitSingleExpressionReturn;
+    PreferNonVoid &= Other.PreferNonVoid;
+    ExpectedCustomAttributeKinds |= Other.ExpectedCustomAttributeKinds;
+  }
+
   Type getIdealType() const { return IdealType; }
 
   void setIdealType(Type IdealType) { this->IdealType = IdealType; }

include/swift/IDE/ExprCompletion.h

@@ -90,9 +90,8 @@ class ExprTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
         AddUnresolvedMemberCompletions(AddUnresolvedMemberCompletions) {}
 
   /// \param CCLoc The location of the code completion token.
-  void deliverResults(SourceLoc CCLoc,
-                      ide::CodeCompletionContext &CompletionCtx,
-                      CodeCompletionConsumer &Consumer);
+  void collectResults(SourceLoc CCLoc,
+                      ide::CodeCompletionContext &CompletionCtx);
 };
 
 } // end namespace ide

include/swift/IDE/KeyPathCompletion.h

@@ -37,9 +37,8 @@ class KeyPathTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
 public:
   KeyPathTypeCheckCompletionCallback(KeyPathExpr *KeyPath) : KeyPath(KeyPath) {}
 
-  void deliverResults(DeclContext *DC, SourceLoc DotLoc,
-                      ide::CodeCompletionContext &CompletionCtx,
-                      CodeCompletionConsumer &Consumer);
+  void collectResults(DeclContext *DC, SourceLoc DotLoc,
+                      ide::CodeCompletionContext &CompletionCtx);
 };
 
 } // end namespace ide

include/swift/IDE/PostfixCompletion.h

@@ -103,10 +103,9 @@ class PostfixCompletionCallback : public TypeCheckCompletionCallback {
   ///                         \p DotLoc is invalid
   /// \param HasLeadingSpace Whether there is a space separating the exiting
   ///                        expression and the code completion token.
-  void deliverResults(SourceLoc DotLoc, bool IsInSelector,
+  void collectResults(SourceLoc DotLoc, bool IsInSelector,
                       bool IncludeOperators, bool HasLeadingSpace,
-                      CodeCompletionContext &CompletionCtx,
-                      CodeCompletionConsumer &Consumer);
+                      CodeCompletionContext &CompletionCtx);
 };
 
 } // end namespace ide