[CodeCompletion] Rename a few types/methods for clarity plus other small refactorings (NFC)

Also put subclasses of TypeCheckCompletionCallback into their own header.

Author: Nathan Hawes

include/swift/AST/ASTContext.h

@@ -122,7 +122,7 @@ namespace swift {
   class IndexSubset;
   struct SILAutoDiffDerivativeFunctionKey;
   struct InterfaceSubContextDelegate;
-  class CompletionCollector;
+  class TypeCheckCompletionCallback;
 
   enum class KnownProtocolKind : uint8_t;
 
@@ -253,7 +253,7 @@ class ASTContext final {
   /// Diags - The diagnostics engine.
   DiagnosticEngine &Diags;
 
-  CompletionCollector *CompletionCallback = nullptr;
+  TypeCheckCompletionCallback *CompletionCallback = nullptr;
 
   /// The request-evaluator that is used to process various requests.
   Evaluator evaluator;

include/swift/Sema/CodeCompletionTypeChecking.h

@@ -0,0 +1,82 @@
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// Provides TypeCheckCompletionCallback implementations for the various kinds
+/// of code completion. These extract and persist information needed to compute
+/// completion results from the solutions formed during expression typechecking.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SEMA_CODECOMPLETIONTYPECHECKING_H
+#define SWIFT_SEMA_CODECOMPLETIONTYPECHECKING_H
+
+namespace swift {
+  class Decl;
+  class DeclContext;
+  class Type;
+  class ValueDecl;
+  class CodeCompletionExpr;
+
+  namespace constraints {
+    class Solution;
+  }
+
+  class TypeCheckCompletionCallback {
+  public:
+    /// Called for each solution produced while  type-checking an expression
+    /// containing a code completion expression.
+    virtual void sawSolution(const constraints::Solution &solution) = 0;
+    virtual ~TypeCheckCompletionCallback() {}
+  };
+
+
+  /// Used to collect and store information needed to perform member completion
+  /// (\c CompletionKind::DotExpr ) from the solutions formed during expression
+  /// type-checking.
+  class DotExprTypeCheckCompletionCallback: public TypeCheckCompletionCallback {
+  public:
+    struct Result {
+      Type BaseTy;
+      ValueDecl* BaseDecl;
+      SmallVector<Type, 4> ExpectedTypes;
+      bool ExpectsNonVoid;
+      bool BaseIsStaticMetaType;
+      bool IsSingleExpressionBody;
+    };
+
+  private:
+    DeclContext *DC;
+    CodeCompletionExpr *CompletionExpr;
+    SmallVector<Result, 4> Results;
+    llvm::DenseMap<std::pair<Type, Decl*>, size_t> BaseToSolutionIdx;
+    bool GotCallback = false;
+
+  public:
+    DotExprTypeCheckCompletionCallback(DeclContext *DC,
+                                       CodeCompletionExpr *CompletionExpr)
+      : DC(DC), CompletionExpr(CompletionExpr) {}
+
+    /// Get the results collected from any sawSolutions() callbacks recevied so
+    /// far.
+    ArrayRef<Result> getResults() const { return Results; }
+
+    /// True if at least one solution was passed via the \c sawSolution
+    /// callback.
+    bool gotCallback() const { return GotCallback; }
+
+    /// Typecheck the code completion expression in isolation, calling
+    /// \c sawSolution for each solution formed.
+    void fallbackTypeCheck();
+
+    void sawSolution(const constraints::Solution &solution) override;
+  };
+}
+
+#endif

include/swift/Sema/IDETypeChecking.h

@@ -44,64 +44,6 @@ namespace swift {
   class Type;
   class ValueDecl;
   struct PrintOptions;
-  class CodeCompletionExpr;
-
-  namespace constraints {
-    class Solution;
-  }
-
-  namespace ide {
-    class CodeCompletionContext;
-    class CodeCompletionConsumer;
-  }
-
-  class CompletionCollector {
-  public:
-    virtual void sawSolution(const constraints::Solution &solution) = 0;
-    virtual ~CompletionCollector() {}
-  };
-
-
-  class DotExprLookup: public CompletionCollector {
-    struct SolutionInfo {
-      Type BaseTy;
-      ValueDecl* BaseDecl;
-      SmallVector<Type, 4> ExpectedTypes;
-      bool ExpectsNonVoid;
-      bool BaseIsStaticMetaType;
-      bool IsSingleExpressionBody;
-    };
-
-    SourceLoc DotLoc;
-    DeclContext *DC;
-    CodeCompletionExpr *CompletionExpr;
-    SmallVector<SolutionInfo, 4> Solutions;
-    llvm::DenseMap<std::pair<Type, Decl*>, size_t> BaseToSolutionIdx;
-    bool GotCallback = false;
-
-  public:
-    DotExprLookup(SourceLoc DotLoc, DeclContext *DC,
-                  CodeCompletionExpr *CompletionExpr)
-      : DotLoc(DotLoc), DC(DC), CompletionExpr(CompletionExpr) {}
-
-    /// Lookup the completion members on the base expressions extracted from the
-    /// solutions seen so far and pass them to the given \c Consumer.
-    void performLookup(ide::CodeCompletionContext &CompletionCtx,
-                       ide::CodeCompletionConsumer &Consumer,
-                       bool isInSelector) const;
-
-    /// True if a solution was passed via the \c sawSolution callback.
-    bool gotCallback() const { return GotCallback; }
-
-    /// Typecheck the code completion expression in isolation, calling
-    /// \c sawSolution for each solution formed.
-    void fallbackTypeCheck();
-
-  private:
-    /// Called for each solution produced while  type-checking an expression containing a code
-    /// completion expression.
-    void sawSolution(const constraints::Solution &solution) override;
-  };
 
   /// Typecheck binding initializer at \p bindingIndex.
   void typeCheckPatternBinding(PatternBindingDecl *PBD, unsigned bindingIndex);

lib/IDE/CodeCompletion.cpp

@@ -35,6 +35,7 @@
 #include "swift/IDE/Utils.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "swift/Sema/CodeCompletionTypeChecking.h"
 #include "swift/Syntax/SyntaxKind.h"
 #include "swift/Strings.h"
 #include "swift/Subsystems.h"
@@ -5911,17 +5912,18 @@ static void deliverCompletionResults(CodeCompletionContext &CompletionContext,
                                    DCForModules);
 }
 
-void DotExprLookup::performLookup(ide::CodeCompletionContext &CompletionCtx,
-                                  CodeCompletionConsumer &Consumer,
-                                  bool IsInSelector) const {
+void deliverDotExprResults(
+    ArrayRef<DotExprTypeCheckCompletionCallback::Result> Solutions,
+    Expr *BaseExpr, DeclContext *DC, SourceLoc DotLoc, bool IsInSelector,
+    ide::CodeCompletionContext &CompletionCtx,
+    CodeCompletionConsumer &Consumer) {
   ASTContext &Ctx = DC->getASTContext();
   CompletionLookup Lookup(CompletionCtx.getResultSink(), Ctx, DC,
                           &CompletionCtx);
 
   if (DotLoc.isValid())
     Lookup.setHaveDot(DotLoc);
 
-  Expr *BaseExpr = CompletionExpr->getBase();
   Lookup.setIsSuperRefExpr(isa<SuperRefExpr>(BaseExpr));
 
   if (auto *DRE = dyn_cast<DeclRefExpr>(BaseExpr))
@@ -5980,21 +5982,26 @@ bool CodeCompletionCallbacksImpl::trySolverCompletion() {
     assert(CodeCompleteTokenExpr);
     assert(CurDeclContext);
 
-    DotExprLookup Lookup(DotLoc, CurDeclContext, CodeCompleteTokenExpr);
-    llvm::SaveAndRestore<CompletionCollector*>
+    DotExprTypeCheckCompletionCallback Lookup(CurDeclContext,
+                                              CodeCompleteTokenExpr);
+    llvm::SaveAndRestore<TypeCheckCompletionCallback*>
       CompletionCollector(Context.CompletionCallback, &Lookup);
     typeCheckContextAt(CurDeclContext, CompletionLoc);
 
     // This (hopefully) only happens in cases where the expression isn't
     // typechecked during normal compilation either (e.g. member completion in a
-    // switch case where there switched value is invalid). Having normal
+    // switch case where there control expression is invalid). Having normal
     // typechecking still resolve even these cases would be beneficial for
     // tooling in general though.
     if (!Lookup.gotCallback())
       Lookup.fallbackTypeCheck();
 
     addKeywords(CompletionContext.getResultSink(), MaybeFuncBody);
-    Lookup.performLookup(CompletionContext, Consumer, isInsideObjCSelector());
+
+    Expr *CheckedBase = CodeCompleteTokenExpr->getBase();
+    deliverDotExprResults(Lookup.getResults(), CheckedBase, CurDeclContext,
+                          DotLoc, isInsideObjCSelector(), CompletionContext,
+                          Consumer);
     return true;
   }
   default:

lib/IDE/ExprContextAnalysis.h

@@ -22,7 +22,6 @@ namespace swift {
 class DeclContext;
 class Expr;
 class ValueDecl;
-class CompletionCollector;
 
 namespace ide {
 enum class SemanticContextKind;

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -41,6 +41,7 @@
 #include "swift/Basic/STLExtras.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "swift/Sema/CodeCompletionTypeChecking.h"
 #include "swift/Strings.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerUnion.h"
@@ -865,7 +866,13 @@ bool TypeChecker::typeCheckForCodeCompletion(
                                                /*contextualType=*/Type(),
                                                /*isDiscarded=*/true);
 
-    (void)solveForCodeCompletion(completionTarget);
+    switch (solveForCodeCompletion(completionTarget)) {
+    case CompletionResult::Ok:
+    case CompletionResult::Fallback:
+      break;
+    case CompletionResult::NotApplicable:
+      llvm_unreachable("solve on CodeCompletionExpr produced not applicable?");
+    }
   }
   return true;
 }
@@ -966,15 +973,16 @@ swift::lookupSemanticMember(DeclContext *DC, Type ty, DeclName name) {
   return TypeChecker::lookupMember(DC, ty, DeclNameRef(name), None);
 }
 
-void DotExprLookup::fallbackTypeCheck() {
+void DotExprTypeCheckCompletionCallback::fallbackTypeCheck() {
   assert(!gotCallback());
   SolutionApplicationTarget completionTarget(CompletionExpr, DC, CTP_Unused,
                                              Type(), /*isDiscared=*/true);
   TypeChecker::typeCheckForCodeCompletion(
       completionTarget, [&](const Solution &S) { sawSolution(S); });
 }
 
-void DotExprLookup::sawSolution(const constraints::Solution &S) {
+void DotExprTypeCheckCompletionCallback::
+sawSolution(const constraints::Solution &S) {
   GotCallback = true;
   auto &CS = S.getConstraintSystem();
 
@@ -1047,9 +1055,9 @@ void DotExprLookup::sawSolution(const constraints::Solution &S) {
     ReferencedDecl = SelectedOverload->choice.getDeclOrNull();
 
   auto Key = std::make_pair(BaseTy, ReferencedDecl);
-  auto Ret = BaseToSolutionIdx.insert({Key, Solutions.size()});
+  auto Ret = BaseToSolutionIdx.insert({Key, Results.size()});
   if (!Ret.second && ExpectedTy) {
-    Solutions[Ret.first->getSecond()].ExpectedTypes.push_back(ExpectedTy);
+    Results[Ret.first->getSecond()].ExpectedTypes.push_back(ExpectedTy);
   } else {
     bool ISDMT = S.isStaticallyDerivedMetatype(ParsedExpr);
     bool SingleExprBody = false;
@@ -1070,9 +1078,9 @@ void DotExprLookup::sawSolution(const constraints::Solution &S) {
       }
     }
 
-    Solutions.push_back(
+    Results.push_back(
         {BaseTy, ReferencedDecl, {}, DisallowVoid, ISDMT, SingleExprBody});
     if (ExpectedTy)
-      Solutions.back().ExpectedTypes.push_back(ExpectedTy);
+      Results.back().ExpectedTypes.push_back(ExpectedTy);
   }
 }

lib/Sema/TypeCheckConstraints.cpp

@@ -39,7 +39,7 @@
 #include "swift/Basic/Statistic.h"
 #include "swift/Parse/Confusables.h"
 #include "swift/Parse/Lexer.h"
-#include "swift/Sema/IDETypeChecking.h"
+#include "swift/Sema/CodeCompletionTypeChecking.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"

lib/Sema/TypeChecker.h

@@ -42,7 +42,6 @@ class TypeResolution;
 class TypeResolutionOptions;
 class TypoCorrectionResults;
 class ExprPattern;
-class CompletionCollector;
 enum class TypeResolutionStage : uint8_t;
 
 namespace constraints {

test/IDE/complete_enum_elements.swift

@@ -57,7 +57,7 @@
 // RUN: %FileCheck %s -check-prefix=QUX_ENUM_NO_DOT < %t.enum.txt
 
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=ENUM_QUAL_DOT_1 > %t.enum.txt
-// RUN: %FileCheck %s -check-prefix=FOO_ENUM_DOT_INVALID < %t.enum.txt
+// RUN: %FileCheck %s -check-prefix=FOO_ENUM_DOT < %t.enum.txt
 
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=ENUM_QUAL_DOT_2 > %t.enum.txt
 // RUN: %FileCheck %s -check-prefix=BAR_ENUM_DOT < %t.enum.txt
@@ -127,17 +127,6 @@ enum FooEnum: CaseIterable {
 // FOO_ENUM_DOT_CONTEXT-NEXT: Decl[StaticVar]/CurrNominal: allCases[#[FooEnum]#]{{; name=.+$}}
 // FOO_ENUM_DOT_CONTEXT-NEXT: End completions
 
-// FOO_ENUM_DOT_INVALID: Begin completions
-// FOO_ENUM_DOT_INVALID-NEXT: Keyword[self]/CurrNominal: self[#FooEnum.Type#]; name=self
-// FOO_ENUM_DOT_INVALID-NEXT: Keyword/CurrNominal: Type[#FooEnum.Type#]; name=Type
-// FOO_ENUM_DOT_INVALID-NEXT: Decl[EnumElement]/CurrNominal: Foo1[#FooEnum#]{{; name=.+$}}
-// FOO_ENUM_DOT_INVALID-NEXT: Decl[EnumElement]/CurrNominal: Foo2[#FooEnum#]{{; name=.+$}}
-// FOO_ENUM_DOT_INVALID-NEXT: Decl[StaticVar]/CurrNominal: alias1[#FooEnum#]{{; name=.+$}}
-// FOO_ENUM_DOT_INVALID-NEXT: Decl[InstanceMethod]/CurrNominal: hash({#(self): FooEnum#})[#(into: inout Hasher) -> Void#]{{; name=.+$}}
-// FOO_ENUM_DOT_INVALID-NEXT: Decl[TypeAlias]/CurrNominal: AllCases[#[FooEnum]#]{{; name=.+$}}
-// FOO_ENUM_DOT_INVALID-NEXT: Decl[StaticVar]/CurrNominal: allCases[#[FooEnum]#]{{; name=.+$}}
-// FOO_ENUM_DOT_INVALID-NEXT: End completions
-
 // FOO_ENUM_DOT_ELEMENTS: Begin completions, 13 items
 // FOO_ENUM_DOT_ELEMENTS-NEXT: Decl[EnumElement]/ExprSpecific/TypeRelation[Identical]: Foo1[#FooEnum#]{{; name=.+$}}
 // FOO_ENUM_DOT_ELEMENTS-NEXT: Decl[EnumElement]/ExprSpecific/TypeRelation[Identical]: Foo2[#FooEnum#]{{; name=.+$}}