[CodeCompletion] Move TypeCheckCompletionCallbacks to IDE

ahoppen · ahoppen · commit 51777d5ff773 · 2022-03-21T20:04:32.000+01:00
diff --git a/include/swift/AST/ASTContext.h b/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;
diff --git a/include/swift/IDE/ArgumentCompletion.h b/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 {
diff --git a/include/swift/IDE/DotExprCompletion.h b/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 {
diff --git a/include/swift/IDE/ExprCompletion.h b/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 {
diff --git a/include/swift/IDE/KeyPathCompletion.h b/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 {
diff --git a/include/swift/IDE/TypeCheckCompletionCallback.h b/include/swift/IDE/TypeCheckCompletionCallback.h
@@ -0,0 +1,81 @@
+//===--- 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;
+
+public:
+  virtual ~TypeCheckCompletionCallback() {}
+
+  /// Called for each solution produced while type-checking an expression
+  /// that the code completion expression participates in.
+  virtual void sawSolution(const constraints::Solution &solution) {
+    GotCallback = true;
+  };
+
+  /// 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);
+
+} // namespace ide
+} // namespace swift
+
+#endif // SWIFT_IDE_TYPECHECKCOMPLETIONCALLBACK_H
diff --git a/include/swift/IDE/UnresolvedMemberCompletion.h b/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 {
diff --git a/include/swift/Sema/CodeCompletionTypeChecking.h b/include/swift/Sema/CodeCompletionTypeChecking.h
diff --git a/include/swift/Sema/CompletionContextFinder.h b/include/swift/Sema/CompletionContextFinder.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 {
 
diff --git a/include/swift/Sema/IDETypeChecking.h b/include/swift/Sema/IDETypeChecking.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);
 
diff --git a/lib/IDE/CMakeLists.txt b/lib/IDE/CMakeLists.txt
@@ -30,6 +30,7 @@ add_swift_host_library(swiftIDE STATIC
   REPLCodeCompletion.cpp
   SwiftSourceDocInfo.cpp
   SyntaxModel.cpp
+  TypeCheckCompletionCallback.cpp
   UnresolvedMemberCompletion.cpp
   Utils.cpp
   IDETypeChecking.cpp
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -42,10 +42,10 @@
 #include "swift/IDE/DotExprCompletion.h"
 #include "swift/IDE/ExprCompletion.h"
 #include "swift/IDE/KeyPathCompletion.h"
+#include "swift/IDE/TypeCheckCompletionCallback.h"
 #include "swift/IDE/UnresolvedMemberCompletion.h"
 #include "swift/IDE/Utils.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
-#include "swift/Sema/CodeCompletionTypeChecking.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "swift/Strings.h"
 #include "swift/Subsystems.h"
diff --git a/lib/IDE/TypeCheckCompletionCallback.cpp b/lib/IDE/TypeCheckCompletionCallback.cpp
@@ -0,0 +1,110 @@
+//===--- TypeCheckCompletionCallback.cpp ----------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/IDE/TypeCheckCompletionCallback.h"
+#include "swift/Sema/CompletionContextFinder.h"
+#include "swift/Sema/ConstraintSystem.h"
+#include "swift/Sema/IDETypeChecking.h"
+
+using namespace swift;
+using namespace swift::ide;
+using namespace swift::constraints;
+
+void TypeCheckCompletionCallback::fallbackTypeCheck(DeclContext *DC) {
+  assert(!GotCallback);
+
+  CompletionContextFinder finder(DC);
+  if (!finder.hasCompletionExpr())
+    return;
+
+  auto fallback = finder.getFallbackCompletionExpr();
+  if (!fallback)
+    return;
+
+  SolutionApplicationTarget completionTarget(fallback->E, fallback->DC,
+                                             CTP_Unused, Type(),
+                                             /*isDiscared=*/true);
+  typeCheckForCodeCompletion(completionTarget, /*needsPrecheck=*/true,
+                             [&](const Solution &S) { sawSolution(S); });
+}
+
+// MARK: - Utility functions for subclasses of TypeCheckCompletionCallback
+
+Type swift::ide::getTypeForCompletion(const constraints::Solution &S, Expr *E) {
+  if (!S.hasType(E)) {
+    assert(false && "Expression wasn't type checked?");
+    return nullptr;
+  }
+
+  auto &CS = S.getConstraintSystem();
+
+  // To aid code completion, we need to attempt to convert type placeholders
+  // back into underlying generic parameters if possible, since type
+  // of the code completion expression is used as "expected" (or contextual)
+  // type so it's helpful to know what requirements it has to filter
+  // the list of possible member candidates e.g.
+  //
+  // \code
+  // func test<T: P>(_: [T]) {}
+  //
+  // test(42.#^MEMBERS^#)
+  // \code
+  //
+  // It's impossible to resolve `T` in this case but code completion
+  // expression should still have a type of `[T]` instead of `[<<hole>>]`
+  // because it helps to produce correct contextual member list based on
+  // a conformance requirement associated with generic parameter `T`.
+  if (isa<CodeCompletionExpr>(E)) {
+    auto completionTy = S.getType(E).transform([&](Type type) -> Type {
+      if (auto *typeVar = type->getAs<TypeVariableType>())
+        return S.getFixedType(typeVar);
+      return type;
+    });
+
+    return S.simplifyType(completionTy.transform([&](Type type) {
+      if (auto *placeholder = type->getAs<PlaceholderType>()) {
+        if (auto *typeVar =
+                placeholder->getOriginator().dyn_cast<TypeVariableType *>()) {
+          if (auto *GP = typeVar->getImpl().getGenericParameter()) {
+            // Code completion depends on generic parameter type being
+            // represented in terms of `ArchetypeType` since it's easy
+            // to extract protocol requirements from it.
+            if (auto *GPD = GP->getDecl())
+              return GPD->getInnermostDeclContext()->mapTypeIntoContext(GP);
+          }
+        }
+
+        return Type(CS.getASTContext().TheUnresolvedType);
+      }
+
+      return type;
+    }));
+  }
+
+  return S.getResolvedType(E);
+}
+
+bool swift::ide::isImplicitSingleExpressionReturn(ConstraintSystem &CS,
+                                                  Expr *CompletionExpr) {
+  Expr *ParentExpr = CS.getParentExpr(CompletionExpr);
+  if (!ParentExpr)
+    return CS.getContextualTypePurpose(CompletionExpr) == CTP_ReturnSingleExpr;
+
+  if (auto *ParentCE = dyn_cast<ClosureExpr>(ParentExpr)) {
+    if (ParentCE->hasSingleExpressionBody() &&
+        ParentCE->getSingleExpressionBody() == CompletionExpr) {
+      ASTNode Last = ParentCE->getBody()->getLastElement();
+      return !Last.isStmt(StmtKind::Return) || Last.isImplicit();
+    }
+  }
+  return false;
+}
diff --git a/lib/Sema/TypeCheckCodeCompletion.cpp b/lib/Sema/TypeCheckCodeCompletion.cpp
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
