Merge pull request swiftlang#33749 from nathawes/new-member-completion

[CodeCompletion] Update member completion to handle ambiguous and invalid base expressions

Author: Nathan Hawes

include/swift/AST/ASTContext.h

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

include/swift/IDE/CodeCompletion.h

@@ -870,7 +870,7 @@ class CodeCompletionContext {
     /// but should not hide any results.
     SingleExpressionBody,
 
-    /// There are known contextual types.
+    /// There are known contextual types, or there aren't but a nonvoid type is expected.
     Required,
   };
 

include/swift/Parse/CodeCompletionCallbacks.h

@@ -119,7 +119,7 @@ class CodeCompletionCallbacks {
   virtual void setAttrTargetDeclKind(Optional<DeclKind> DK) {}
 
   /// Complete expr-dot after we have consumed the dot.
-  virtual void completeDotExpr(Expr *E, SourceLoc DotLoc) {};
+  virtual void completeDotExpr(CodeCompletionExpr *E, SourceLoc DotLoc) {};
 
   /// Complete the beginning of a statement or expression.
   virtual void completeStmtOrExpr(CodeCompletionExpr *E) {};

include/swift/Parse/Parser.h

@@ -692,6 +692,15 @@ class Parser {
       Context.LangOpts.ParseForSyntaxTreeOnly;
   }
 
+  /// If a function or closure body consists of a single expression, determine
+  /// whether we should turn wrap it in a return statement or not.
+  ///
+  /// We don't do this transformation for non-solver-based code completion
+  /// positions, as the source may be incomplete and the type mismatch in the
+  /// return statement will just confuse the type checker.
+  bool shouldSuppressSingleExpressionBodyTransform(
+      ParserStatus Status, MutableArrayRef<ASTNode> BodyElems);
+
 public:
   InFlightDiagnostic diagnose(SourceLoc Loc, Diagnostic Diag) {
     if (Diags.isDiagnosticPointsToFirstBadToken(Diag.getID()) &&

include/swift/Sema/CodeCompletionTypeChecking.h

@@ -0,0 +1,83 @@
+//===--- CodeCompletionTypeChecking.h  --------------------------*- C++ -*-===//
+//
+// 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