[CodeCompletion] Migrate postfix expr completion to solver-based

Author: ahoppen

include/swift/IDE/CompletionLookup.h

@@ -492,7 +492,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);
 
@@ -502,7 +509,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/DotExprCompletion.h

@@ -25,23 +25,60 @@ namespace ide {
 /// type-checking.
 class DotExprTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
   struct Result {
+    /// The type that we are completing on. Will never be null.
     Type BaseTy;
+
+    /// The we were able to determine it, 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 suggested
+    /// 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 occurrs 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
     /// 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) const;
+
+    /// Merge this result with \p Other. Assumes that they can be merged.
+    void merge(const Result &Other);
   };
 
   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;
 
@@ -54,8 +91,18 @@ class DotExprTypeCheckCompletionCallback : 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/CodeCompletionCallbacks.h

@@ -132,8 +132,9 @@ class CodeCompletionCallbacks {
   /// -- no tokens provided by user.
   virtual void completeForEachSequenceBeginning(CodeCompletionExpr *E) {};
 
-  /// 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/IDETypeChecking.h

@@ -19,9 +19,10 @@
 #ifndef SWIFT_SEMA_IDETYPECHECKING_H
 #define SWIFT_SEMA_IDETYPECHECKING_H
 
+#include "swift/AST/Expr.h"
 #include "swift/AST/Identifier.h"
-#include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/OptionSet.h"
+#include "swift/Basic/SourceLoc.h"
 #include <memory>
 #include <tuple>
 
@@ -163,6 +164,11 @@ namespace swift {
       constraints::SolutionApplicationTarget &target, bool needsPrecheck,
       llvm::function_ref<void(const constraints::Solution &)> callback);
 
+  /// Thunk around \c TypeChecker::resolveDeclRefExpr to make it
+  /// available to \c swift::ide.
+  Expr *resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *Context,
+                           bool replaceInvalidRefsWithErrors);
+
   LookupResult
   lookupSemanticMember(DeclContext *DC, Type ty, DeclName name);
 

lib/IDE/CodeCompletion.cpp

@@ -231,7 +231,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   void completeStmtOrExpr(CodeCompletionExpr *E) override;
   void completePostfixExprBeginning(CodeCompletionExpr *E) override;
   void completeForEachSequenceBeginning(CodeCompletionExpr *E) 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;
 
@@ -354,7 +354,8 @@ void CodeCompletionCallbacksImpl::completeForEachSequenceBeginning(
   CodeCompleteTokenExpr = E;
 }
 
-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.
@@ -368,7 +369,8 @@ void CodeCompletionCallbacksImpl::completePostfixExpr(Expr *E, bool hasSpace) {
     CompleteExprSelectorContext = ParseExprSelectorContext;
   }
 
-  ParsedExpr = E;
+  ParsedExpr = E->getBase();
+  CodeCompleteTokenExpr = E;
   CurDeclContext = P.CurDeclContext;
 }
 
@@ -1331,6 +1333,7 @@ bool CodeCompletionCallbacksImpl::trySolverCompletion(bool MaybeFuncBody) {
     : CurDeclContext->getASTContext().SourceMgr.getCodeCompletionLoc();
 
   switch (Kind) {
+  case CompletionKind::PostfixExpr:
   case CompletionKind::DotExpr: {
     assert(CodeCompleteTokenExpr);
     assert(CurDeclContext);
@@ -1351,9 +1354,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: {
@@ -1587,26 +1591,10 @@ void CodeCompletionCallbacksImpl::doneParsing() {
   case CompletionKind::AfterPoundExpr:
   case CompletionKind::AccessorBeginning:
   case CompletionKind::CaseStmtBeginning:
+  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::PostfixExprParen: {
     Lookup.setHaveLParen(true);
 
@@ -1656,7 +1644,8 @@ void CodeCompletionCallbacksImpl::doneParsing() {
       if (isDynamicLookup(*ExprType))
         Lookup.setIsDynamicLookup();
 
-      Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl());
+      Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl(),
+                                     /*IncludeFunctionCallCompletions=*/true);
     } else {
       SourceLoc Loc = P.Context.SourceMgr.getCodeCompletionLoc();
       Lookup.getValueCompletionsInDeclContext(Loc, KeyPathFilter,
@@ -1822,7 +1811,8 @@ void CodeCompletionCallbacksImpl::doneParsing() {
 
         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

@@ -2134,6 +2134,8 @@ void CompletionLookup::getPostfixKeywordCompletions(Type ExprType,
   if (IsSuperRefExpr)
     return;
 
+  NeedLeadingDot = !HaveDot;
+
   if (!ExprType->getAs<ModuleType>()) {
     addKeyword(getTokenText(tok::kw_self), ExprType->getRValueType(),
                SemanticContextKind::CurrentNominal,
@@ -2156,7 +2158,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;
 
@@ -2189,7 +2192,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))
     return;
@@ -2252,7 +2255,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(Sink,
                                       CodeCompletionResultKind::BuiltinOperator,
                                       SemanticContextKind::None);
@@ -2263,12 +2266,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,
@@ -2387,8 +2389,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

@@ -46,7 +46,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() override;
@@ -58,10 +58,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() {