[Evaluator] Use the evaluator directly from AST entry points.

Rather than call through the LazyResolver (when available) to satisfy
queries that may require type checking, call into the evaluator
directly: it will make use of the type checker (via the lazy resolver)
when necessary. This change should allow us to use the
request-evaluator’s cache for state rather than mutable AST state,
as well as the ability to see requests that were evaluated after
type checking.

Author: DougGregor

include/swift/AST/LazyResolver.h

@@ -71,20 +71,6 @@ class LazyResolver {
   /// Resolve the "is Objective-C" bit for the given declaration.
   virtual void resolveIsObjC(ValueDecl *VD) = 0;
 
-  /// Retrieve the superclass of the given class.
-  virtual Type getSuperclass(const ClassDecl *classDecl) = 0;
-
-  /// Retrieve the superclass of the given protocol.
-  virtual Type getSuperclass(const ProtocolDecl *protocolDecl) = 0;
-
-  /// Resolve the raw type of the given enum.
-  virtual Type getRawType(EnumDecl *enumDecl) = 0;
-
-  /// Get a specific inherited type from the given declaration.
-  virtual Type getInheritedType(
-                        llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                        unsigned index) = 0;
-
   /// Resolve the trailing where clause of the given protocol in-place.
   virtual void resolveTrailingWhereClause(ProtocolDecl *proto) = 0;
 

include/swift/AST/TypeCheckRequests.h

@@ -125,7 +125,7 @@ class EnumRawTypeRequest :
 #define SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE 10
 
 #define SWIFT_TYPEID_ZONE SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE
-#define SWIFT_TYPEID_HEADER "swift/Sema/TypeCheckerTypeIDZone.def"
+#define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"
 
 // Set up reporting of evaluated requests.
@@ -135,7 +135,7 @@ inline void reportEvaluatedRequest(UnifiedStatsReporter &stats,  \
                             const RequestType &request) {        \
   ++stats.getFrontendCounters().RequestType;                     \
 }
-#include "swift/Sema/TypeCheckerTypeIDZone.def"
+#include "swift/AST/TypeCheckerTypeIDZone.def"
 #undef SWIFT_TYPEID
 
 } // end namespace swift

lib/AST/Decl.cpp

@@ -35,6 +35,7 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ResilienceExpansion.h"
 #include "swift/AST/Stmt.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/SwiftNameTranslation.h"
 #include "clang/Lex/MacroInfo.h"
@@ -959,12 +960,8 @@ ExtensionDecl::takeConformanceLoaderSlow() {
 
 Type ExtensionDecl::getInheritedType(unsigned index) const {
   ASTContext &ctx = getASTContext();
-  if (auto lazyResolver = ctx.getLazyResolver()) {
-    return lazyResolver->getInheritedType(const_cast<ExtensionDecl *>(this),
-                                          index);
-  }
-
-  return getInherited()[index].getType();
+  return ctx.evaluator(InheritedTypeRequest{const_cast<ExtensionDecl *>(this),
+                                            index});
 }
 
 bool ExtensionDecl::isConstrainedExtension() const {
@@ -2329,12 +2326,8 @@ void ValueDecl::copyFormalAccessFrom(const ValueDecl *source,
 
 Type TypeDecl::getInheritedType(unsigned index) const {
   ASTContext &ctx = getASTContext();
-  if (auto lazyResolver = ctx.getLazyResolver()) {
-    return lazyResolver->getInheritedType(const_cast<TypeDecl *>(this),
-                                          index);
-  }
-
-  return getInherited()[index].getType();
+  return ctx.evaluator(InheritedTypeRequest{const_cast<TypeDecl *>(this),
+                                            index});
 }
 
 Type TypeDecl::getDeclaredInterfaceType() const {
@@ -2829,11 +2822,7 @@ EnumDecl::EnumDecl(SourceLoc EnumLoc,
 
 Type EnumDecl::getRawType() const {
   ASTContext &ctx = getASTContext();
-  if (auto lazyResolver = ctx.getLazyResolver()) {
-    return lazyResolver->getRawType(const_cast<EnumDecl *>(this));
-  }
-
-  return LazySemanticInfo.RawType.getPointer();
+  return ctx.evaluator(EnumRawTypeRequest{const_cast<EnumDecl *>(this)});
 }
 
 StructDecl::StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,
@@ -3286,11 +3275,7 @@ ProtocolDecl::getAssociatedTypeMembers() const {
 
 Type ProtocolDecl::getSuperclass() const {
   ASTContext &ctx = getASTContext();
-  if (auto lazyResolver = ctx.getLazyResolver()) {
-    return lazyResolver->getSuperclass(this);
-  }
-
-  return LazySemanticInfo.Superclass.getPointer();
+  return ctx.evaluator(SuperclassTypeRequest{const_cast<ProtocolDecl *>(this)});
 }
 
 ClassDecl *ProtocolDecl::getSuperclassDecl() const {
@@ -5698,11 +5683,7 @@ Type TypeBase::getSwiftNewtypeUnderlyingType() {
 
 Type ClassDecl::getSuperclass() const {
   ASTContext &ctx = getASTContext();
-  if (auto lazyResolver = ctx.getLazyResolver()) {
-    return lazyResolver->getSuperclass(this);
-  }
-
-  return LazySemanticInfo.Superclass.getPointer();
+  return ctx.evaluator(SuperclassTypeRequest{const_cast<ClassDecl *>(this)});
 }
 
 ClassDecl *ClassDecl::getSuperclassDecl() const {

lib/AST/TypeCheckRequests.cpp

@@ -9,21 +9,18 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-#include "GenericTypeResolver.h"
-#include "TypeChecker.h"
-#include "swift/Sema/TypeCheckRequests.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/Decl.h"
-#include "swift/AST/ExistentialLayout.h"
+#include "swift/AST/DiagnosticsCommon.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/Types.h"
-#include "swift/Subsystems.h"
 
 using namespace swift;
 
 namespace swift {
-// Implement the type checker type zone (zone 10).
+// Implement the type checker type zone (zone 10).
 #define SWIFT_TYPEID_ZONE 10
-#define SWIFT_TYPEID_HEADER "swift/Sema/TypeCheckerTypeIDZone.def"
+#define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/ImplementTypeIDZone.h"
 
 }
@@ -54,71 +51,6 @@ TypeLoc &InheritedTypeRequest::getTypeLoc(
   return decl.get<ExtensionDecl *>()->getInherited()[index];
 }
 
-Type InheritedTypeRequest::evaluate(
-                        Evaluator &evaluator,
-                        llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                        unsigned index) const {
-  // Figure out how to resolve types.
-  TypeResolutionOptions options;
-  DeclContext *dc;
-  if (auto typeDecl = decl.dyn_cast<TypeDecl *>()) {
-    if (auto nominal = dyn_cast<NominalTypeDecl>(typeDecl)) {
-      dc = nominal;
-      options |= TypeResolutionFlags::GenericSignature;
-      options |= TypeResolutionFlags::InheritanceClause;
-      options |= TypeResolutionFlags::AllowUnavailableProtocol;
-    } else {
-      dc = typeDecl->getDeclContext();
-
-      if (isa<GenericTypeParamDecl>(typeDecl)) {
-        // For generic parameters, we want name lookup to look at just the
-        // signature of the enclosing entity.
-        if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
-          dc = nominal;
-          options |= TypeResolutionFlags::GenericSignature;
-        } else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
-          dc = ext;
-          options |= TypeResolutionFlags::GenericSignature;
-        } else if (auto func = dyn_cast<AbstractFunctionDecl>(dc)) {
-          dc = func;
-          options |= TypeResolutionFlags::GenericSignature;
-        } else if (!dc->isModuleScopeContext()) {
-          // Skip the generic parameter's context entirely.
-          dc = dc->getParent();
-        }
-      }
-    }
-  } else {
-    auto ext = decl.get<ExtensionDecl *>();
-    dc = ext;
-    options |= TypeResolutionFlags::GenericSignature;
-    options |= TypeResolutionFlags::InheritanceClause;
-    options |= TypeResolutionFlags::AllowUnavailableProtocol;
-  }
-
-  ProtocolRequirementTypeResolver protoResolver;
-  GenericTypeToArchetypeResolver archetypeResolver(dc);
-  GenericTypeResolver *resolver;
-  if (isa<ProtocolDecl>(dc)) {
-    resolver = &protoResolver;
-  } else {
-    resolver = &archetypeResolver;
-  }
-
-  // FIXME: Hack for calls through here when we have no type checker.
-  auto lazyResolver = dc->getASTContext().getLazyResolver();
-  if (!lazyResolver) return ErrorType::get(dc->getASTContext());
-
-  TypeChecker &tc = *static_cast<TypeChecker *>(lazyResolver);
-  TypeLoc &typeLoc = getTypeLoc(decl, index);
-
-  Type inheritedType =
-    tc.resolveType(typeLoc.getTypeRepr(), dc, options, resolver);
-  if (inheritedType && !isa<ProtocolDecl>(dc))
-    inheritedType = inheritedType->mapTypeOutOfContext();
-  return inheritedType ? inheritedType : ErrorType::get(tc.Context);
-}
-
 void InheritedTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
   const auto &storage = getStorage();
   auto &typeLoc = getTypeLoc(std::get<0>(storage), std::get<1>(storage));
@@ -149,40 +81,6 @@ void InheritedTypeRequest::cacheResult(Type value) const {
 //----------------------------------------------------------------------------//
 // Superclass computation.
 //----------------------------------------------------------------------------//
-Type SuperclassTypeRequest::evaluate(Evaluator &evaluator,
-                                     NominalTypeDecl *nominalDecl) const {
-  assert(isa<ClassDecl>(nominalDecl) || isa<ProtocolDecl>(nominalDecl));
-
-  for (unsigned int idx : indices(nominalDecl->getInherited())) {
-    Type inheritedType = evaluator(InheritedTypeRequest{nominalDecl, idx});
-    if (!inheritedType) continue;
-
-    // If we found a class, return it.
-    if (inheritedType->getClassOrBoundGenericClass()) {
-      if (inheritedType->hasArchetype())
-        return inheritedType->mapTypeOutOfContext();
-
-      return inheritedType;
-    }
-
-    // If we found an existential with a superclass bound, return it.
-    if (inheritedType->isExistentialType()) {
-      if (auto superclassType =
-            inheritedType->getExistentialLayout().superclass) {
-        if (superclassType->getClassOrBoundGenericClass()) {
-          if (superclassType->hasArchetype())
-            return superclassType->mapTypeOutOfContext();
-
-          return superclassType;
-        }
-      }
-    }
-  }
-
-  // No superclass.
-  return Type();
-}
-
 void SuperclassTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
   // FIXME: Improve this diagnostic.
   auto nominalDecl = std::get<0>(getStorage());
@@ -223,26 +121,6 @@ void SuperclassTypeRequest::cacheResult(Type value) const {
 //----------------------------------------------------------------------------//
 // Enum raw type computation.
 //----------------------------------------------------------------------------//
-Type EnumRawTypeRequest::evaluate(Evaluator &evaluator,
-                                  EnumDecl *enumDecl) const {
-  for (unsigned int idx : indices(enumDecl->getInherited())) {
-    Type inheritedType = evaluator(InheritedTypeRequest{enumDecl, idx});
-    if (!inheritedType) continue;
-
-    // Skip existential types.
-    if (inheritedType->isExistentialType()) continue;
-
-    // We found a raw type; return it.
-    if (inheritedType->hasArchetype())
-      return inheritedType->mapTypeOutOfContext();
-
-    return inheritedType;
-  }
-
-  // No raw type.
-  return Type();
-}
-
 void EnumRawTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
   // FIXME: Improve this diagnostic.
   auto enumDecl = std::get<0>(getStorage());
@@ -267,16 +145,3 @@ void EnumRawTypeRequest::cacheResult(Type value) const {
   auto enumDecl = std::get<0>(getStorage());
   enumDecl->LazySemanticInfo.RawType.setPointerAndInt(value, true);
 }
-
-// Define request evaluation functions for each of the type checker requests.
-static AbstractRequestFunction *typeCheckerRequestFunctions[] = {
-#define SWIFT_TYPEID(Name)                                    \
-  reinterpret_cast<AbstractRequestFunction *>(&Name::evaluateRequest),
-#include "swift/Sema/TypeCheckerTypeIDZone.def"
-#undef SWIFT_TYPEID
-};
-
-void swift::registerTypeCheckerRequestFunctions(Evaluator &evaluator) {
-  evaluator.registerRequestFunctions(SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE,
-                                     typeCheckerRequestFunctions);
-}

lib/Sema/TypeCheckDecl.cpp

@@ -233,26 +233,6 @@ static void addImplicitConformances(
 /// Check that the declaration attributes are ok.
 static void validateAttributes(TypeChecker &TC, Decl *D);
 
-Type TypeChecker::getSuperclass(const ClassDecl *classDecl) {
-  return Context.evaluator(
-           SuperclassTypeRequest(const_cast<ClassDecl *>(classDecl)));
-}
-
-Type TypeChecker::getSuperclass(const ProtocolDecl *protocolDecl) {
-  return Context.evaluator(
-           SuperclassTypeRequest(const_cast<ProtocolDecl *>(protocolDecl)));
-}
-
-Type TypeChecker::getRawType(EnumDecl *enumDecl) {
-  return Context.evaluator(EnumRawTypeRequest(enumDecl));
-}
-
-Type TypeChecker::getInheritedType(
-                         llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                         unsigned index) {
-  return Context.evaluator(InheritedTypeRequest(decl, index));
-}
-
 void TypeChecker::resolveTrailingWhereClause(ProtocolDecl *proto) {
   ProtocolRequirementTypeResolver resolver;
   validateWhereClauses(proto, &resolver);

lib/Sema/TypeCheckRequestFunctions.cpp

@@ -151,4 +151,3 @@ void swift::registerTypeCheckerRequestFunctions(Evaluator &evaluator) {
   evaluator.registerRequestFunctions(SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE,
                                      typeCheckerRequestFunctions);
 }
-

lib/Sema/TypeChecker.h

@@ -1544,15 +1544,6 @@ class TypeChecker final : public LazyResolver {
       GenericRequirementsCheckListener *listener = nullptr,
       SubstOptions options = None);
 
-  /// Get the superclass of the given class.
-  Type getSuperclass(const ClassDecl *classDecl) override;
-
-  /// Get the superclass of the given protocol.
-  Type getSuperclass(const ProtocolDecl *protocolDecl) override;
-
-  /// Get the raw type of the given enum.
-  Type getRawType(EnumDecl *enumDecl) override;
-
   /// Resolve the inherited protocols of a given protocol.
   void resolveInheritedProtocols(ProtocolDecl *protocol);
 
@@ -1561,10 +1552,6 @@ class TypeChecker final : public LazyResolver {
   void validateWhereClauses(ProtocolDecl *protocol,
                             GenericTypeResolver *resolver);
 
-  /// Get a specific inherited type from the given declaration.
-  Type getInheritedType(llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                        unsigned index) override;
-
   void resolveTrailingWhereClause(ProtocolDecl *proto) override;
 
   /// Check the inheritance clause of the given declaration.

unittests/AST/TestContext.cpp

@@ -13,6 +13,7 @@
 #include "TestContext.h"
 #include "swift/AST/Module.h"
 #include "swift/Strings.h"
+#include "swift/Subsystems.h"
 
 using namespace swift;
 using namespace swift::unittest;
@@ -34,6 +35,7 @@ static void declareOptionalType(ASTContext &ctx, SourceFile *fileForLookups,
 
 TestContext::TestContext(ShouldDeclareOptionalTypes optionals)
     : Ctx(*ASTContext::get(LangOpts, SearchPathOpts, SourceMgr, Diags)) {
+  registerTypeCheckerRequestFunctions(Ctx.evaluator);
   auto stdlibID = Ctx.getIdentifier(STDLIB_NAME);
   auto *module = ModuleDecl::create(stdlibID, Ctx);
   Ctx.LoadedModules[stdlibID] = module;