Merge pull request #41885 from ahoppen/pr/refactor-solver-completion

[CodeCompletion] Some refactorings surrounding solver-based completion

Author: ahoppen

include/swift/AST/ASTContext.h

@@ -130,7 +130,6 @@ namespace swift {
   class IndexSubset;
   struct SILAutoDiffDerivativeFunctionKey;
   struct InterfaceSubContextDelegate;
-  class TypeCheckCompletionCallback;
 
   enum class KnownProtocolKind : uint8_t;
 
@@ -146,6 +145,10 @@ namespace syntax {
   class SyntaxArena;
 }
 
+namespace ide {
+  class TypeCheckCompletionCallback;
+}
+
 /// Lists the set of "known" Foundation entities that are used in the
 /// compiler.
 ///
@@ -281,7 +284,7 @@ class ASTContext final {
   /// the cancellation might return with any result.
   std::shared_ptr<std::atomic<bool>> CancellationFlag = nullptr;
 
-  TypeCheckCompletionCallback *CompletionCallback = nullptr;
+  ide::TypeCheckCompletionCallback *CompletionCallback = nullptr;
 
   /// The request-evaluator that is used to process various requests.
   Evaluator evaluator;

include/swift/IDE/ArgumentCompletion.h

@@ -16,7 +16,7 @@
 #include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionContext.h"
 #include "swift/IDE/PossibleParamInfo.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 
 namespace swift {
 namespace ide {
@@ -45,9 +45,14 @@ class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
     Type BaseType;
     /// True if an argument label precedes the completion location.
     bool HasLabel;
+    /// Whether the surrounding context is async and thus calling async
+    /// functions is supported.
+    bool IsInAsyncContext;
   };
 
   CodeCompletionExpr *CompletionExpr;
+  DeclContext *DC;
+
   SmallVector<Result, 4> Results;
 
   /// Populates a vector of parameters to suggest along with a vector of types
@@ -58,11 +63,12 @@ class ArgumentTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
                          SmallVectorImpl<PossibleParamInfo> &Params,
                          SmallVectorImpl<Type> &Types);
 
-public:
-  ArgumentTypeCheckCompletionCallback(CodeCompletionExpr *CompletionExpr)
-      : CompletionExpr(CompletionExpr) {}
+  void sawSolutionImpl(const constraints::Solution &solution) override;
 
-  void sawSolution(const constraints::Solution &solution) override;
+public:
+  ArgumentTypeCheckCompletionCallback(CodeCompletionExpr *CompletionExpr,
+                                      DeclContext *DC)
+      : CompletionExpr(CompletionExpr), DC(DC) {}
 
   /// \param IncludeSignature Whether to include a suggestion for the entire
   /// function signature instead of suggesting individual labels. Used when

include/swift/IDE/CompletionLookup.h

@@ -76,6 +76,9 @@ bool isCodeCompletionAtTopLevel(const DeclContext *DC);
 ///     }
 bool isCompletionDeclContextLocalContext(DeclContext *DC);
 
+/// Returns \c true if \p DC can handles async call.
+bool canDeclContextHandleAsync(const DeclContext *DC);
+
 /// Return \c true if the completion happens at top-level of a library file.
 bool isCodeCompletionAtTopLevelOfLibraryFile(const DeclContext *DC);
 

include/swift/IDE/DotExprCompletion.h

@@ -15,7 +15,7 @@
 
 #include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionContext.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 
 namespace swift {
 namespace ide {
@@ -31,22 +31,29 @@ class DotExprTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
     bool ExpectsNonVoid;
     bool BaseIsStaticMetaType;
     bool IsImplicitSingleExpressionReturn;
+
+    /// Whether the surrounding context is async and thus calling async
+    /// functions is supported.
+    bool IsInAsyncContext;
   };
 
   CodeCompletionExpr *CompletionExpr;
+  DeclContext *DC;
+
   SmallVector<Result, 4> Results;
   llvm::DenseMap<std::pair<Type, Decl *>, size_t> BaseToSolutionIdx;
 
+  void sawSolutionImpl(const constraints::Solution &solution) override;
+
 public:
-  DotExprTypeCheckCompletionCallback(CodeCompletionExpr *CompletionExpr)
-      : CompletionExpr(CompletionExpr) {}
+  DotExprTypeCheckCompletionCallback(CodeCompletionExpr *CompletionExpr,
+                                     DeclContext *DC)
+      : CompletionExpr(CompletionExpr), DC(DC) {}
 
   /// Typecheck the code completion expression in isolation, calling
   /// \c sawSolution for each solution formed.
   void fallbackTypeCheck(DeclContext *DC) override;
 
-  void sawSolution(const constraints::Solution &solution) override;
-
   void deliverResults(Expr *BaseExpr, DeclContext *DC, SourceLoc DotLoc,
                       bool IsInSelector, CodeCompletionContext &CompletionCtx,
                       CodeCompletionConsumer &Consumer);

include/swift/IDE/ExprCompletion.h

@@ -15,7 +15,7 @@
 
 #include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionContext.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 
 namespace swift {
 namespace ide {
@@ -46,14 +46,14 @@ class ExprTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
 
   SmallVector<Result, 4> Results;
 
+  void sawSolutionImpl(const constraints::Solution &solution) override;
+
 public:
   /// \param DC The decl context in which the \p CompletionExpr occurs.
   ExprTypeCheckCompletionCallback(CodeCompletionExpr *CompletionExpr,
                                   DeclContext *DC)
       : CompletionExpr(CompletionExpr), DC(DC) {}
 
-  void sawSolution(const constraints::Solution &solution) override;
-
   /// \param CCLoc The location of the code completion token.
   void deliverResults(SourceLoc CCLoc,
                       ide::CodeCompletionContext &CompletionCtx,

include/swift/IDE/KeyPathCompletion.h

@@ -15,7 +15,7 @@
 
 #include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionContext.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 
 namespace swift {
 namespace ide {
@@ -32,11 +32,11 @@ class KeyPathTypeCheckCompletionCallback : public TypeCheckCompletionCallback {
   KeyPathExpr *KeyPath;
   SmallVector<Result, 4> Results;
 
+  void sawSolutionImpl(const constraints::Solution &solution) override;
+
 public:
   KeyPathTypeCheckCompletionCallback(KeyPathExpr *KeyPath) : KeyPath(KeyPath) {}
 
-  void sawSolution(const constraints::Solution &solution) override;
-
   void deliverResults(DeclContext *DC, SourceLoc DotLoc,
                       ide::CodeCompletionContext &CompletionCtx,
                       CodeCompletionConsumer &Consumer);

include/swift/IDE/TypeCheckCompletionCallback.h

@@ -0,0 +1,90 @@
+//===--- TypeCheckCompletionCallback.h  -----------------------------------===//
+//
+// 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_IDE_TYPECHECKCOMPLETIONCALLBACK_H
+#define SWIFT_IDE_TYPECHECKCOMPLETIONCALLBACK_H
+
+#include "swift/AST/Expr.h"
+#include "swift/AST/Type.h"
+#include "swift/Basic/LLVM.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+class Decl;
+class DeclContext;
+class Type;
+class ValueDecl;
+class CodeCompletionExpr;
+
+namespace constraints {
+class ConstraintSystem;
+class Solution;
+} // namespace constraints
+
+namespace ide {
+
+class TypeCheckCompletionCallback {
+  bool GotCallback = false;
+
+protected:
+  /// Subclasses of \c TypeCheckCompletionCallback handle solutions discovered
+  /// by the constraint system in this function
+  virtual void sawSolutionImpl(const constraints::Solution &solution) = 0;
+
+public:
+  virtual ~TypeCheckCompletionCallback() {}
+
+  /// Called for each solution produced while type-checking an expression
+  /// that the code completion expression participates in.
+  void sawSolution(const constraints::Solution &solution) {
+    GotCallback = true;
+    sawSolutionImpl(solution);
+  };
+
+  /// True if at least one solution was passed via the \c sawSolution
+  /// callback.
+  bool gotCallback() const { return GotCallback; }
+
+  /// Typecheck the code completion expression in its outermost expression
+  /// context, calling \c sawSolution for each solution formed.
+  virtual void fallbackTypeCheck(DeclContext *DC);
+};
+
+// MARK: - Utility functions for subclasses of TypeCheckCompletionCallback
+
+Type getTypeForCompletion(const constraints::Solution &S, Expr *E);
+
+/// Whether the given completion expression is the only expression in its
+/// containing closure or function body and its value is implicitly returned.
+///
+/// If these conditions are met, code completion needs to avoid penalizing
+/// completion results that don't match the expected return type when
+/// computing type relations, as since no return statement was explicitly
+/// written by the user, it's possible they intend the single expression not
+/// as the return value but merely the first entry in a multi-statement body
+/// they just haven't finished writing yet.
+bool isImplicitSingleExpressionReturn(constraints::ConstraintSystem &CS,
+                                      Expr *CompletionExpr);
+
+/// Returns \c true iff the decl context \p DC allows calling async functions.
+bool isContextAsync(const constraints::Solution &S, DeclContext *DC);
+
+} // namespace ide
+} // namespace swift
+
+#endif // SWIFT_IDE_TYPECHECKCOMPLETIONCALLBACK_H

include/swift/IDE/UnresolvedMemberCompletion.h

@@ -15,7 +15,7 @@
 
 #include "swift/IDE/CodeCompletionConsumer.h"
 #include "swift/IDE/CodeCompletionContext.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 
 namespace swift {
 namespace ide {
@@ -25,21 +25,27 @@ namespace ide {
 /// formed during expression type-checking.
 class UnresolvedMemberTypeCheckCompletionCallback
     : public TypeCheckCompletionCallback {
-  struct ExprResult {
+  struct Result {
     Type ExpectedTy;
     bool IsImplicitSingleExpressionReturn;
+
+    /// Whether the surrounding context is async and thus calling async
+    /// functions is supported.
+    bool IsInAsyncContext;
   };
 
   CodeCompletionExpr *CompletionExpr;
-  SmallVector<ExprResult, 4> ExprResults;
-  SmallVector<Type, 1> EnumPatternTypes;
+  DeclContext *DC;
+
+  SmallVector<Result, 4> ExprResults;
+  SmallVector<Result, 1> EnumPatternTypes;
+
+  void sawSolutionImpl(const constraints::Solution &solution) override;
 
 public:
   UnresolvedMemberTypeCheckCompletionCallback(
-      CodeCompletionExpr *CompletionExpr)
-      : CompletionExpr(CompletionExpr) {}
-
-  void sawSolution(const constraints::Solution &solution) override;
+      CodeCompletionExpr *CompletionExpr, DeclContext *DC)
+      : CompletionExpr(CompletionExpr), DC(DC) {}
 
   void deliverResults(DeclContext *DC, SourceLoc DotLoc,
                       ide::CodeCompletionContext &CompletionCtx,

include/swift/Sema/CodeCompletionTypeChecking.h

@@ -16,7 +16,7 @@
 #include "swift/AST/ASTNode.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Expr.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 
 namespace swift {
 

include/swift/Sema/CompletionContextFinder.h

@@ -159,20 +159,6 @@ namespace swift {
       constraints::SolutionApplicationTarget &target, bool needsPrecheck,
       llvm::function_ref<void(const constraints::Solution &)> callback);
 
-  Type getTypeForCompletion(const constraints::Solution &S, Expr *E);
-
-  /// Whether the given completion expression is the only expression in its
-  /// containing closure or function body and its value is implicitly returned.
-  ///
-  /// If these conditions are met, code completion needs to avoid penalizing
-  /// completion results that don't match the expected return type when
-  /// computing type relations, as since no return statement was explicitly
-  /// written by the user, it's possible they intend the single expression not
-  /// as the return value but merely the first entry in a multi-statement body
-  /// they just haven't finished writing yet.
-  bool isImplicitSingleExpressionReturn(constraints::ConstraintSystem &CS,
-                                        Expr *CompletionExpr);
-
   LookupResult
   lookupSemanticMember(DeclContext *DC, Type ty, DeclName name);