Migrate the remaining completion kinds to solver-based + rework type-checking of string interpolations

include/swift/IDE/CompletionLookup.h

@@ -519,7 +519,14 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void getPostfixKeywordCompletions(Type ExprType, Expr *ParsedExpr);
 
-  void getValueExprCompletions(Type ExprType, ValueDecl *VD = nullptr);
+  /// Add code completion results after an expression of type \p ExprType.
+  /// This includes members as well as call patterns if \p ExprType is a
+  /// function type.
+  /// If \p IsDeclUnapplied is \c true, we are completing after a refernce to
+  /// \p VD that hasn't been called yet. Thus, \p VD has type \p ExprType and we
+  /// can use \p VD to enrich call pattern completions of \p ExprType.
+  void getValueExprCompletions(Type ExprType, ValueDecl *VD = nullptr,
+                               bool IsDeclUnapplied = false);
 
   void collectOperators(SmallVectorImpl<OperatorDecl *> &results);
 
@@ -529,7 +536,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void tryPostfixOperator(Expr *expr, PostfixOperatorDecl *op);
 
-  void addAssignmentOperator(Type RHSType, Type resultType);
+  void addAssignmentOperator(Type RHSType);
 
   void addInfixOperatorCompletion(OperatorDecl *op, Type resultType,
                                   Type RHSType);

include/swift/IDE/PostfixCompletion.h

@@ -20,16 +20,41 @@
 namespace swift {
 namespace ide {
 
-/// Used to collect and store information needed to perform member completion
-/// (\c CompletionKind::DotExpr ) from the solutions formed during expression
-/// type-checking.
+/// Used to collect and store information needed to perform postfix completion
+/// (either <base>.#^COMPLETE^# or <base> #^COMPLETE^#).
 class PostfixCompletionCallback : public TypeCheckCompletionCallback {
   struct Result {
+    /// The type that we are completing on. Will never be null.
     Type BaseTy;
+
+    /// The decl that we are completing on. Is \c nullptr if we are completing
+    /// on an expression.
     ValueDecl *BaseDecl;
+
+    /// Whether \c BaseDecl refers to a function that has not been called yet.
+    /// In such cases, we know that \p BaseTy is the type of \p BaseDecl and we
+    /// can use \p BaseDecl for more detailed call pattern completions.
+    bool IsBaseDeclUnapplied;
+
+    /// If the expression we are completing on statically refers to a metatype,
+    /// that is if it's something like 'MyType'. In such cases we want to offer
+    /// constructor call pattern completions and don't want to suggeste
+    /// operators that work on metatypes.
+    bool BaseIsStaticMetaType;
+
+    /// The types that the completion is expected to produce.
     SmallVector<Type, 4> ExpectedTypes;
+
+    /// Whether results that produce 'Void' should be disfavored. This happens
+    /// if the context is requiring a value. Once a completion produces 'Void',
+    /// we know that we can't retrieve a value from it anymore.
     bool ExpectsNonVoid;
-    bool BaseIsStaticMetaType;
+
+    /// If the code completion expression occurs as a single statement in a
+    /// single-expression closure. In such cases we don't want to disfavor
+    /// results that produce 'Void' because the user might intend to make the
+    /// closure a multi-statment closure, in which case this expression is no
+    /// longer implicitly returned.
     bool IsImplicitSingleExpressionReturn;
 
     /// Whether the surrounding context is async and thus calling async
@@ -40,13 +65,24 @@ class PostfixCompletionCallback : public TypeCheckCompletionCallback {
     /// haven't been saved to the AST.
     llvm::DenseMap<AbstractClosureExpr *, ClosureActorIsolation>
         ClosureActorIsolations;
+
+    /// Checks whether this result has the same \c BaseTy and \c BaseDecl as
+    /// \p Other and if the two can thus be merged to be one value lookup in
+    /// \c deliverResults.
+    bool canBeMergedWith(const Result &Other, DeclContext &DC) const;
+
+    /// Merge this result with \p Other. Assumes that they can be merged.
+    void merge(const Result &Other, DeclContext &DC);
   };
 
   CodeCompletionExpr *CompletionExpr;
   DeclContext *DC;
 
   SmallVector<Result, 4> Results;
-  llvm::DenseMap<std::pair<Type, Decl *>, size_t> BaseToSolutionIdx;
+
+  /// Add a result to \c Results, merging it with an existing result, if
+  /// possible.
+  void addResult(const Result &Res);
 
   void sawSolutionImpl(const constraints::Solution &solution) override;
 
@@ -58,8 +94,18 @@ class PostfixCompletionCallback : public TypeCheckCompletionCallback {
   /// \c sawSolution for each solution formed.
   void fallbackTypeCheck(DeclContext *DC) override;
 
-  void deliverResults(Expr *BaseExpr, DeclContext *DC, SourceLoc DotLoc,
-                      bool IsInSelector, CodeCompletionContext &CompletionCtx,
+  /// Deliver code completion results that were discoverd by \c sawSolution to
+  /// \p Consumer.
+  /// \param DotLoc If we are completing after a dot, the location of the dot,
+  ///               otherwise an invalid SourceLoc.
+  /// \param IsInSelector Whether we are completing in an Objective-C selector.
+  /// \param IncludeOperators If operators should be suggested. Assumes that
+  ///                         \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,
+                      bool IncludeOperators, bool HasLeadingSpace,
+                      CodeCompletionContext &CompletionCtx,
                       CodeCompletionConsumer &Consumer);
 };
 

include/swift/IDE/UnresolvedMemberCompletion.h

@@ -32,6 +32,14 @@ class UnresolvedMemberTypeCheckCompletionCallback
     /// Whether the surrounding context is async and thus calling async
     /// functions is supported.
     bool IsInAsyncContext;
+
+    /// Checks whether this result has the same \c BaseTy and \c BaseDecl as
+    /// \p Other and if the two can thus be merged to be one value lookup in
+    /// \c deliverResults.
+    bool canBeMergedWith(const Result &Other, DeclContext &DC) const;
+
+    /// Merge this result with \p Other. Assumes that they can be merged.
+    void merge(const Result &Other, DeclContext &DC);
   };
 
   CodeCompletionExpr *CompletionExpr;
@@ -40,6 +48,10 @@ class UnresolvedMemberTypeCheckCompletionCallback
   SmallVector<Result, 4> ExprResults;
   SmallVector<Result, 1> EnumPatternTypes;
 
+  /// Add a result to \c Results, merging it with an existing result, if
+  /// possible.
+  void addExprResult(const Result &Res);
+
   void sawSolutionImpl(const constraints::Solution &solution) override;
 
 public:

include/swift/Parse/IDEInspectionCallbacks.h

@@ -147,8 +147,9 @@ class CodeCompletionCallbacks {
   /// Complete the \c in keyword in a for-each loop.
   virtual void completeForEachInKeyword(){};
 
-  /// Complete a given expr-postfix.
-  virtual void completePostfixExpr(Expr *E, bool hasSpace) {};
+  /// Complete a expr-postfix. The \c CodeCompletionExpr has the expression it
+  /// is completing after set as its base.
+  virtual void completePostfixExpr(CodeCompletionExpr *E, bool hasSpace){};
 
   /// Complete a given expr-postfix, given that there is a following
   /// left parenthesis.

include/swift/Sema/ConstraintSystem.h

@@ -472,6 +472,9 @@ class TypeVariableType::Implementation {
   /// Determine whether this type variable represents a closure type.
   bool isClosureType() const;
 
+  /// Determine whether this type variable represents a type of tap expression.
+  bool isTapType() const;
+
   /// Determine whether this type variable represents one of the
   /// parameter types associated with a closure.
   bool isClosureParameterType() const;
@@ -935,6 +938,9 @@ enum ScoreKind: unsigned int {
   /// A reference to an @unavailable declaration.
   SK_Unavailable,
   /// A reference to an async function in a synchronous context.
+  ///
+  /// \note Any score kind after this is considered a conversion that doesn't
+  /// require fixing the source and will be ignored during code completion.
   SK_AsyncInSyncMismatch,
   /// Synchronous function in an asynchronous context or a conversion of
   /// a synchronous function to an asynchronous one.
@@ -3951,6 +3957,20 @@ class ConstraintSystem {
   /// \returns `true` if pack expansion has been resolved, `false` otherwise.
   bool resolvePackExpansion(TypeVariableType *typeVar, Type contextualType);
 
+  /// Bind tap expression to the given contextual type and generate
+  /// constraints for its body.
+  ///
+  /// \param typeVar The type variable representing the tap expression.
+  /// \param contextualType The contextual type this tap expression
+  /// would be bound to.
+  /// \param locator The locator associated with contextual type.
+  ///
+  /// \returns `true` if it was possible to generate constraints for
+  /// the body and assign fixed type to the tap expression, `false`
+  /// otherwise.
+  bool resolveTapBody(TypeVariableType *typeVar, Type contextualType,
+                      ConstraintLocatorBuilder locator);
+
   /// Assign a fixed type to the given type variable.
   ///
   /// \param typeVar The type variable to bind.
@@ -4354,6 +4374,14 @@ class ConstraintSystem {
                       FreeTypeVariableBinding allowFreeTypeVariables =
                           FreeTypeVariableBinding::Disallow);
 
+  /// Generate constraints for the body of the given tap expression.
+  ///
+  /// \param tap the tap expression
+  ///
+  /// \returns \c true if constraint generation failed, \c false otherwise
+  [[nodiscard]]
+  bool generateConstraints(TapExpr *tap);
+
   /// Generate constraints for the body of the given function or closure.
   ///
   /// \param fn The function or closure expression
@@ -5203,7 +5231,8 @@ class ConstraintSystem {
 public:
   /// Increase the score of the given kind for the current (partial) solution
   /// along the.
-  void increaseScore(ScoreKind kind, unsigned value = 1);
+  void increaseScore(ScoreKind kind, ConstraintLocatorBuilder Locator,
+                     unsigned value = 1);
 
   /// Determine whether this solution is guaranteed to be worse than the best
   /// solution found so far.
@@ -5285,6 +5314,22 @@ class ConstraintSystem {
           llvm::Optional<SyntacticElementTarget>(SyntacticElementTarget)>
           rewriteTarget);
 
+  /// Apply the given solution to the given tap expression.
+  ///
+  /// \param solution The solution to apply.
+  /// \param tapExpr The tap expression to which the solution is being applied.
+  /// \param currentDC The declaration context in which transformations
+  /// will be applied.
+  /// \param rewriteTarget Function that performs a rewrite of any
+  /// solution application target within the context.
+  ///
+  /// \returns true if solution cannot be applied.
+  bool applySolutionToBody(Solution &solution, TapExpr *tapExpr,
+                           DeclContext *&currentDC,
+                           std::function<llvm::Optional<SyntacticElementTarget>(
+                               SyntacticElementTarget)>
+                               rewriteTarget);
+
   /// Reorder the disjunctive clauses for a given expression to
   /// increase the likelihood that a favored constraint will be successfully
   /// resolved before any others.

lib/AST/ASTNode.cpp

@@ -41,6 +41,7 @@ SourceRange ASTNode::getSourceRange() const {
   if (const auto *I = this->dyn_cast<CaseLabelItem *>()) {
     return I->getSourceRange();
   }
+  assert(!isNull() && "Null ASTNode doesn't have a source range");
   llvm_unreachable("unsupported AST node");
 }
 

lib/IDE/ArgumentCompletion.cpp

@@ -236,7 +236,18 @@ void ArgumentTypeCheckCompletionCallback::sawSolutionImpl(const Solution &S) {
     for (auto Idx : range(0, ParamsToPass.size())) {
       bool Optional = false;
       if (Info.ValueRef) {
-        if (const ParamDecl *DeclParam = getParameterAt(Info.ValueRef, Idx)) {
+        if (Info.ValueRef.getDecl()->isInstanceMember() &&
+            !doesMemberRefApplyCurriedSelf(Info.BaseTy,
+                                           Info.ValueRef.getDecl())) {
+          // We are completing in an unapplied instance function, eg.
+          // struct TestStatic {
+          //   func method() ->  Void {}
+          // }
+          // TestStatic.method(#^STATIC^#)
+          // The 'self' parameter is never optional, so don't enter the check
+          // below (which always assumes that self has been applied).
+        } else if (const ParamDecl *DeclParam =
+                       getParameterAt(Info.ValueRef, Idx)) {
           Optional |= DeclParam->isDefaultArgument();
           Optional |= DeclParam->getType()->is<PackExpansionType>();
         }