[CodeCompletion] Migrate postfix expr completion to solver-based

Author: ahoppen

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,9 +20,8 @@
 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.
@@ -32,6 +31,11 @@ class PostfixCompletionCallback : public TypeCheckCompletionCallback {
     /// 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
@@ -90,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/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.

lib/IDE/CodeCompletion.cpp

@@ -259,7 +259,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
   void completePostfixExprBeginning(CodeCompletionExpr *E) override;
   void completeForEachSequenceBeginning(CodeCompletionExpr *E) override;
   void completeForEachInKeyword() override;
-  void completePostfixExpr(Expr *E, bool hasSpace) override;
+  void completePostfixExpr(CodeCompletionExpr *E, bool hasSpace) override;
   void completePostfixExprParen(Expr *E, Expr *CodeCompletionE) override;
   void completeExprKeyPath(KeyPathExpr *KPE, SourceLoc DotLoc) override;
 
@@ -391,7 +391,8 @@ void CodeCompletionCallbacksImpl::completeForEachInKeyword() {
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completePostfixExpr(Expr *E, bool hasSpace) {
+void CodeCompletionCallbacksImpl::completePostfixExpr(CodeCompletionExpr *E,
+                                                      bool hasSpace) {
   assert(P.Tok.is(tok::code_complete));
 
   // Don't produce any results in an enum element.
@@ -405,7 +406,8 @@ void CodeCompletionCallbacksImpl::completePostfixExpr(Expr *E, bool hasSpace) {
     CompleteExprSelectorContext = ParseExprSelectorContext;
   }
 
-  ParsedExpr = E;
+  ParsedExpr = E->getBase();
+  CodeCompleteTokenExpr = E;
   CurDeclContext = P.CurDeclContext;
 }
 
@@ -1469,6 +1471,7 @@ bool CodeCompletionCallbacksImpl::trySolverCompletion(bool MaybeFuncBody) {
   };
 
   switch (Kind) {
+  case CompletionKind::PostfixExpr:
   case CompletionKind::DotExpr: {
     assert(CodeCompleteTokenExpr);
     assert(CurDeclContext);
@@ -1478,9 +1481,10 @@ bool CodeCompletionCallbacksImpl::trySolverCompletion(bool MaybeFuncBody) {
 
     addKeywords(CompletionContext.getResultSink(), MaybeFuncBody);
 
-    Expr *CheckedBase = CodeCompleteTokenExpr->getBase();
-    Lookup.deliverResults(CheckedBase, CurDeclContext, DotLoc,
-                          isInsideObjCSelector(), CompletionContext, Consumer);
+    bool IncludeOperators = (Kind == CompletionKind::PostfixExpr);
+
+    Lookup.deliverResults(DotLoc, isInsideObjCSelector(), IncludeOperators,
+                          HasSpace, CompletionContext, Consumer);
     return true;
   }
   case CompletionKind::UnresolvedMember: {
@@ -1694,26 +1698,10 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
   case CompletionKind::AccessorBeginning:
   case CompletionKind::CaseStmtBeginning:
   case CompletionKind::PostfixExprParen:
+  case CompletionKind::PostfixExpr:
     llvm_unreachable("should be already handled");
     return;
 
-  case CompletionKind::PostfixExpr: {
-    Lookup.setHaveLeadingSpace(HasSpace);
-    if (isDynamicLookup(*ExprType))
-      Lookup.setIsDynamicLookup();
-    Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl());
-    /// We set the type of ParsedExpr explicitly above. But we don't want an
-    /// unresolved type in our AST when we type check again for operator
-    /// completions. Remove the type of the ParsedExpr and see if we can come up
-    /// with something more useful based on the the full sequence expression.
-    if (ParsedExpr->getType()->is<UnresolvedType>()) {
-      ParsedExpr->setType(nullptr);
-    }
-    Lookup.getOperatorCompletions(ParsedExpr, leadingSequenceExprs);
-    Lookup.getPostfixKeywordCompletions(*ExprType, ParsedExpr);
-    break;
-  }
-
   case CompletionKind::KeyPathExprObjC: {
     if (DotLoc.isValid())
       Lookup.setHaveDot(DotLoc);
@@ -1724,7 +1712,8 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
       if (isDynamicLookup(*ExprType))
         Lookup.setIsDynamicLookup();
 
-      Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl());
+      Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl(),
+                                     /*IncludeFunctionCallCompletions=*/true);
     } else {
       SourceLoc Loc = P.Context.SourceMgr.getIDEInspectionTargetLoc();
       Lookup.getValueCompletionsInDeclContext(Loc, KeyPathFilter,
@@ -1949,7 +1938,8 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
 
         if (isDynamicLookup(resultTy))
           Lookup.setIsDynamicLookup();
-        Lookup.getValueExprCompletions(resultTy, /*VD=*/nullptr);
+        Lookup.getValueExprCompletions(resultTy, /*VD=*/nullptr,
+                                       /*IncludeFunctionCallCompletions=*/true);
         Lookup.getOperatorCompletions(analyzedExpr, leadingSequenceExprs);
         Lookup.getPostfixKeywordCompletions(resultTy, analyzedExpr);
       }

lib/IDE/CompletionLookup.cpp

@@ -2307,6 +2307,8 @@ void CompletionLookup::getPostfixKeywordCompletions(Type ExprType,
   if (IsSuperRefExpr)
     return;
 
+  NeedLeadingDot = !HaveDot;
+
   if (!ExprType->getAs<ModuleType>()) {
     addKeyword(getTokenText(tok::kw_self), ExprType->getRValueType(),
                SemanticContextKind::CurrentNominal,
@@ -2329,7 +2331,8 @@ void CompletionLookup::getPostfixKeywordCompletions(Type ExprType,
   }
 }
 
-void CompletionLookup::getValueExprCompletions(Type ExprType, ValueDecl *VD) {
+void CompletionLookup::getValueExprCompletions(Type ExprType, ValueDecl *VD,
+                                               bool IsDeclUnapplied) {
   Kind = LookupKind::ValueExpr;
   NeedLeadingDot = !HaveDot;
 
@@ -2362,7 +2365,7 @@ void CompletionLookup::getValueExprCompletions(Type ExprType, ValueDecl *VD) {
 
   // Handle special cases
   bool isIUO = VD && VD->isImplicitlyUnwrappedOptional();
-  if (tryFunctionCallCompletions(ExprType, VD))
+  if (tryFunctionCallCompletions(ExprType, IsDeclUnapplied ? VD : nullptr))
     return;
   if (tryModuleCompletions(ExprType, {CodeCompletionFilterFlag::Expr,
                                       CodeCompletionFilterFlag::Type}))
@@ -2425,7 +2428,7 @@ void CompletionLookup::tryPostfixOperator(Expr *expr, PostfixOperatorDecl *op) {
   addPostfixOperatorCompletion(op, funcTy->getResult());
 }
 
-void CompletionLookup::addAssignmentOperator(Type RHSType, Type resultType) {
+void CompletionLookup::addAssignmentOperator(Type RHSType) {
   CodeCompletionResultBuilder builder = makeResultBuilder(
       CodeCompletionResultKind::BuiltinOperator, SemanticContextKind::None);
 
@@ -2435,12 +2438,11 @@ void CompletionLookup::addAssignmentOperator(Type RHSType, Type resultType) {
     builder.addWhitespace(" ");
   builder.addEqual();
   builder.addWhitespace(" ");
-  assert(RHSType && resultType);
+  assert(RHSType);
   Type contextTy;
   if (auto typeContext = CurrDeclContext->getInnermostTypeContext())
     contextTy = typeContext->getDeclaredTypeInContext();
   builder.addCallArgument(Identifier(), RHSType, contextTy);
-  addTypeAnnotation(builder, resultType);
 }
 
 void CompletionLookup::addInfixOperatorCompletion(OperatorDecl *op,
@@ -2559,8 +2561,7 @@ void CompletionLookup::getOperatorCompletions(
 
   if (leadingSequence.empty() && LHS->getType() &&
       LHS->getType()->hasLValueType()) {
-    addAssignmentOperator(LHS->getType()->getRValueType(),
-                          CurrDeclContext->getASTContext().TheEmptyTupleType);
+    addAssignmentOperator(LHS->getType()->getRValueType());
   }
 
   // FIXME: unify this with the ?.member completions.

lib/IDE/ConformingMethodList.cpp

@@ -47,7 +47,7 @@ class ConformingMethodListCallbacks : public CodeCompletionCallbacks,
   // Only handle callbacks for suffix completions.
   // {
   void completeDotExpr(CodeCompletionExpr *E, SourceLoc DotLoc) override;
-  void completePostfixExpr(Expr *E, bool hasSpace) override;
+  void completePostfixExpr(CodeCompletionExpr *E, bool hasSpace) override;
   // }
 
   void doneParsing(SourceFile *SrcFile) override;
@@ -59,10 +59,10 @@ void ConformingMethodListCallbacks::completeDotExpr(CodeCompletionExpr *E,
   ParsedExpr = E->getBase();
 }
 
-void ConformingMethodListCallbacks::completePostfixExpr(Expr *E,
+void ConformingMethodListCallbacks::completePostfixExpr(CodeCompletionExpr *E,
                                                         bool hasSpace) {
   CurDeclContext = P.CurDeclContext;
-  ParsedExpr = E;
+  ParsedExpr = E->getBase();
 }
 
 void ConformingMethodListCallbacks::doneParsing(SourceFile *SrcFile) {