Merge pull request swiftlang#26268 from nkcsgexi/ide-type-checking-request

IDE+Evaluator: refactor the implementation of two type checker utilities to evaluator requests. NFC

Author: nkcsgexi

include/swift/AST/Type.h

@@ -611,7 +611,6 @@ inline T *staticCastHelper(const Type &Ty) {
 template <typename T>
 using TypeArrayView = ArrayRefView<Type, T*, staticCastHelper,
                                    /*AllowOrigAccess*/true>;
-
 } // end namespace swift
 
 namespace llvm {

include/swift/Basic/Statistics.def

@@ -224,6 +224,7 @@ FRONTEND_STATISTIC(Sema, NumUnloadedLazyIterableDeclContexts)
 #include "swift/AST/AccessTypeIDZone.def"
 #include "swift/AST/NameLookupTypeIDZone.def"
 #include "swift/AST/TypeCheckerTypeIDZone.def"
+#include "swift/Sema/IDETypeCheckingRequestIDZone.def"
 #include "swift/IDE/IDERequestIDZone.def"
 #undef SWIFT_TYPEID
 

include/swift/Sema/IDETypeCheckingRequestIDZone.def

@@ -0,0 +1,17 @@
+//===-------- IDETypeCheckingIDZone.def -------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This definition file describes the types in the IDE requests
+//  TypeID zone, for use with the TypeID template.
+//
+//===----------------------------------------------------------------------===//
+SWIFT_TYPEID(IsDeclApplicableRequest)

include/swift/Sema/IDETypeCheckingRequests.h

@@ -0,0 +1,107 @@
+//===----- IDETypeCheckingRequests.h - IDE type-check Requests --*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines IDE type checking request using the evaluator model.
+//  The file needs to exist in sema because it needs internal implementation
+//  of the type checker to fulfill some requests
+//
+//===----------------------------------------------------------------------===//
+#ifndef SWIFT_IDE_TYPE_CHECKING_REQUESTS_H
+#define SWIFT_IDE_TYPE_CHECKING_REQUESTS_H
+
+#include "swift/AST/ASTTypeIDs.h"
+#include "swift/AST/Evaluator.h"
+#include "swift/AST/SimpleRequest.h"
+#include "swift/AST/TypeCheckRequests.h"
+
+namespace swift {
+//----------------------------------------------------------------------------//
+// Decl applicability checking
+//----------------------------------------------------------------------------//
+struct DeclApplicabilityOwner {
+  const DeclContext *DC;
+  const Type Ty;
+  const Decl *ExtensionOrMember;
+
+  DeclApplicabilityOwner(const DeclContext *DC, Type Ty, const ExtensionDecl *ED):
+    DC(DC), Ty(Ty), ExtensionOrMember(ED) {}
+  DeclApplicabilityOwner(const DeclContext *DC, Type Ty, const ValueDecl *VD):
+    DC(DC), Ty(Ty), ExtensionOrMember(VD) {}
+
+  friend llvm::hash_code hash_value(const DeclApplicabilityOwner &CI) {
+    return hash_combine(hash_value(CI.Ty.getPointer()),
+                        hash_value(CI.ExtensionOrMember));
+  }
+
+  friend bool operator==(const DeclApplicabilityOwner &lhs,
+                         const DeclApplicabilityOwner &rhs) {
+    return lhs.Ty.getPointer() == rhs.Ty.getPointer() &&
+      lhs.ExtensionOrMember == rhs.ExtensionOrMember;
+  }
+
+  friend bool operator!=(const DeclApplicabilityOwner &lhs,
+                         const DeclApplicabilityOwner &rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend void simple_display(llvm::raw_ostream &out,
+                             const DeclApplicabilityOwner &owner) {
+    out << "Checking if ";
+    simple_display(out, owner.ExtensionOrMember);
+    out << " is applicable for ";
+    simple_display(out, owner.Ty);
+  }
+};
+
+class IsDeclApplicableRequest:
+    public SimpleRequest<IsDeclApplicableRequest,
+                         bool(DeclApplicabilityOwner),
+                         CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator,
+                                DeclApplicabilityOwner Owner) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+  // Source location
+  SourceLoc getNearestLoc() const { return SourceLoc(); };
+};
+
+
+/// The zone number for the IDE.
+#define SWIFT_IDE_TYPE_CHECK_REQUESTS_TYPEID_ZONE 97
+#define SWIFT_TYPEID_ZONE SWIFT_IDE_TYPE_CHECK_REQUESTS_TYPEID_ZONE
+#define SWIFT_TYPEID_HEADER "swift/Sema/IDETypeCheckingRequestIDZone.def"
+#include "swift/Basic/DefineTypeIDZone.h"
+#undef SWIFT_TYPEID_ZONE
+#undef SWIFT_TYPEID_HEADER
+
+// Set up reporting of evaluated requests.
+#define SWIFT_TYPEID(RequestType)                                \
+template<>                                                       \
+inline void reportEvaluatedRequest(UnifiedStatsReporter &stats,  \
+                            const RequestType &request) {        \
+  ++stats.getFrontendCounters().RequestType;                     \
+}
+#include "swift/Sema/IDETypeCheckingRequestIDZone.def"
+#undef SWIFT_TYPEID
+
+} // end namespace swift
+
+#endif // SWIFT_IDE_REQUESTS_H

include/swift/Subsystems.h

@@ -401,6 +401,12 @@ namespace swift {
   /// The ASTContext will automatically call these upon construction.
   void registerIDERequestFunctions(Evaluator &evaluator);
 
+  /// Register type check request functions for IDE's usage with the evaluator.
+  ///
+  /// The ASTContext will automatically call these upon construction.
+  /// Calling registerIDERequestFunctions will invoke this function as well.
+  void registerIDETypeCheckRequestFunctions(Evaluator &evaluator);
+
 } // end namespace swift
 
 #endif // SWIFT_SUBSYSTEMS_H

lib/Frontend/Frontend.cpp

@@ -189,9 +189,10 @@ bool CompilerInstance::setUpASTContextIfNeeded() {
                                 Diagnostics));
   registerTypeCheckerRequestFunctions(Context->evaluator);
 
-  // Migrator and indexing need some IDE requests.
+  // Migrator, indexing and typo correction need some IDE requests.
   if (Invocation.getMigratorOptions().shouldRunMigrator() ||
-      !Invocation.getFrontendOptions().IndexStorePath.empty()) {
+      !Invocation.getFrontendOptions().IndexStorePath.empty() ||
+      Invocation.getLangOptions().TypoCorrectionLimit) {
     registerIDERequestFunctions(Context->evaluator);
   }
   if (setUpModuleLoaders())

lib/IDE/IDERequests.cpp

@@ -46,6 +46,7 @@ reinterpret_cast<AbstractRequestFunction *>(&Name::evaluateRequest),
 void swift::registerIDERequestFunctions(Evaluator &evaluator) {
   evaluator.registerRequestFunctions(SWIFT_IDE_REQUESTS_TYPEID_ZONE,
                                      ideRequestFunctions);
+  registerIDETypeCheckRequestFunctions(evaluator);
 }
 
 //----------------------------------------------------------------------------//

lib/IDE/IDETypeChecking.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/ASTDemangler.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "swift/Sema/IDETypeCheckingRequests.h"
 #include "swift/IDE/SourceEntityWalker.h"
 #include "swift/IDE/IDERequests.h"
 #include "swift/Parse/Lexer.h"
@@ -756,3 +757,15 @@ collectAllOverriddenDecls(ValueDecl *VD, bool IncludeProtocolRequirements,
     CollectOverriddenDeclsRequest(OverridenDeclsOwner(VD,
       IncludeProtocolRequirements, Transitive)), ArrayRef<ValueDecl*>());
 }
+
+bool swift::isExtensionApplied(const DeclContext *DC, Type BaseTy,
+                               const ExtensionDecl *ED) {
+  return evaluateOrDefault(DC->getASTContext().evaluator,
+    IsDeclApplicableRequest(DeclApplicabilityOwner(DC, BaseTy, ED)), false);
+}
+
+bool swift::isMemberDeclApplied(const DeclContext *DC, Type BaseTy,
+                                const ValueDecl *VD) {
+  return evaluateOrDefault(DC->getASTContext().evaluator,
+    IsDeclApplicableRequest(DeclApplicabilityOwner(DC, BaseTy, VD)), false);
+}

lib/Sema/CMakeLists.txt

@@ -61,6 +61,7 @@ add_swift_host_library(swiftSema STATIC
   TypeCheckSwitchStmt.cpp
   TypeCheckType.cpp
   TypeChecker.cpp
+  IDETypeCheckingRequests.cpp
 
   ${EXTRA_TYPECHECKER_FLAGS})
 target_link_libraries(swiftSema PRIVATE

lib/Sema/CSGen.cpp

@@ -3742,7 +3742,7 @@ void ConstraintSystem::optimizeConstraints(Expr *e) {
   e->walk(optimizer);
 }
 
-static bool areGenericRequirementsSatisfied(
+bool swift::areGenericRequirementsSatisfied(
     const DeclContext *DC, const GenericSignature *sig,
     const SubstitutionMap &Substitutions, bool isExtension) {
 
@@ -3766,48 +3766,6 @@ static bool areGenericRequirementsSatisfied(
   return CS.solveSingle().hasValue();
 }
 
-bool swift::isExtensionApplied(const DeclContext *DC, Type BaseTy,
-                               const ExtensionDecl *ED) {
-  // We can't do anything if the base type has unbound generic parameters.
-  // We can't leak type variables into another constraint system.
-  if (BaseTy->hasTypeVariable() || BaseTy->hasUnboundGenericType() ||
-      BaseTy->hasUnresolvedType() || BaseTy->hasError())
-    return true;
-
-  if (!ED->isConstrainedExtension())
-    return true;
-
-  TypeChecker *TC = &createTypeChecker(DC->getASTContext());
-  TC->validateExtension(const_cast<ExtensionDecl *>(ED));
-
-  GenericSignature *genericSig = ED->getGenericSignature();
-  SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
-      DC->getParentModule(), ED->getExtendedNominal());
-  return areGenericRequirementsSatisfied(DC, genericSig, substMap,
-                                         /*isExtension=*/true);
-}
-
-bool swift::isMemberDeclApplied(const DeclContext *DC, Type BaseTy,
-                                const ValueDecl *VD) {
-  // We can't leak type variables into another constraint system.
-  // We can't do anything if the base type has unbound generic parameters.
-  if (BaseTy->hasTypeVariable() || BaseTy->hasUnboundGenericType()||
-      BaseTy->hasUnresolvedType() || BaseTy->hasError())
-    return true;
-
-  const GenericContext *genericDecl = VD->getAsGenericContext();
-  if (!genericDecl)
-    return true;
-  const GenericSignature *genericSig = genericDecl->getGenericSignature();
-  if (!genericSig)
-    return true;
-
-  SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
-      DC->getParentModule(), VD->getDeclContext());
-  return areGenericRequirementsSatisfied(DC, genericSig, substMap,
-                                         /*isExtension=*/false);
-}
-
 static bool canSatisfy(Type type1, Type type2, bool openArchetypes,
                        ConstraintKind kind, DeclContext *dc) {
   std::unique_ptr<TypeChecker> CreatedTC;