[Evaluator] Indirect evaluation of uncached requests through a separate table.

The bundling of the form of a request (e.g., the storage that makes up a request)
with the function that evaluates the request value requires us to perform
ad hoc indirection to address the AST —> Sema layering violation. For
example, ClassDecl::getSuperclass() calls through the LazyResolver (when
available) to form the appropriate request. This means that we cannot
use the the request-evaluator’s cache when LazyResolver is null, forcing
all cached state into the AST.

Provide the evaluator with a zone-based registration system, where each
request “zone” (e.g., the type checker’s requests) registers
callbacks to evaluate each kind of request within that zone. The
evaluator indirects through this table of function pointers, allowing
the request classes themselves to be available at a lower level (AST)
than the functions that perform the computation when the value isn’t
in the cache (e.g., Sema).

We are not taking advantage of the indirection yet; that’ll come in a
follow-up commit.

Author: DougGregor

include/swift/AST/Evaluator.h

@@ -37,12 +37,23 @@ class raw_ostream;
 
 namespace swift {
 
+using llvm::ArrayRef;
 using llvm::Optional;
 using llvm::None;
 
 class DiagnosticEngine;
+class Evaluator;
 class UnifiedStatsReporter;
 
+/// An "abstract" request function pointer, which is the storage type
+/// used for each of the
+using AbstractRequestFunction = void(void);
+
+/// Form the specific request function for the given request type.
+template<typename Request>
+using RequestFunction =
+    typename Request::OutputType(const Request &, Evaluator &);
+
 /// Pretty stack trace handler for an arbitrary request.
 template<typename Request>
 class PrettyStackTraceRequest : public llvm::PrettyStackTraceEntry {
@@ -138,6 +149,18 @@ class Evaluator {
   /// non-null.
   UnifiedStatsReporter *stats = nullptr;
 
+  /// A vector containing the abstract request functions that can compute
+  /// the result of a particular request within a given zone. The
+  /// \c uint8_t is the zone number of the request, and the array is
+  /// indexed by the index of the request type within that zone. Each
+  /// entry is a function pointer that will be reinterpret_cast'd to
+  ///
+  ///   RequestType::OutputType (*)(const RequestType &request,
+  ///                               Evaluator &evaluator);
+  /// and called to satisfy the request.
+  std::vector<std::pair<uint8_t, ArrayRef<AbstractRequestFunction *>>>
+    requestFunctionsByZone;
+
   /// A vector containing all of the active evaluation requests, which
   /// is treated as a stack and is used to detect cycles.
   llvm::SetVector<AnyRequest> activeRequests;
@@ -156,6 +179,19 @@ class Evaluator {
   /// so all clients must cope with cycles.
   llvm::DenseMap<AnyRequest, std::vector<AnyRequest>> dependencies;
 
+  /// Retrieve the request function for the given zone and request IDs.
+  AbstractRequestFunction *getAbstractRequestFunction(uint8_t zoneID,
+                                                      uint8_t requestID) const;
+
+  /// Retrieve the request function for the given request type.
+  template<typename Request>
+  auto getRequestFunction() const -> RequestFunction<Request> * {
+    auto abstractFn = getAbstractRequestFunction(TypeID<Request>::zoneID,
+                                                 TypeID<Request>::localID);
+    assert(abstractFn && "No request function for request");
+    return reinterpret_cast<RequestFunction<Request> *>(abstractFn);
+  }
+
 public:
   /// Construct a new evaluator that can emit cyclic-dependency
   /// diagnostics through the given diagnostics engine.
@@ -165,6 +201,13 @@ class Evaluator {
   /// statistics will be recorded.
   void setStatsReporter(UnifiedStatsReporter *stats) { this->stats = stats; }
 
+  /// Register the set of request functions for the given zone.
+  ///
+  /// These functions will be called to evaluate any requests within that
+  /// zone.
+  void registerRequestFunctions(uint8_t zoneID,
+                                ArrayRef<AbstractRequestFunction *> functions);
+
   /// Evaluate the given request and produce its result,
   /// consulting/populating the cache as required.
   template<typename Request>
@@ -247,7 +290,7 @@ class Evaluator {
     /// Update statistics.
     if (stats) reportEvaluatedRequest(*stats, request);
 
-    return request(*this);
+    return getRequestFunction<Request>()(request, *this);
   }
 
   /// Get the result of a request, consulting an external cache
@@ -301,7 +344,7 @@ class Evaluator {
                          llvm::raw_ostream &out,
                          llvm::DenseSet<AnyRequest> &visitedAnywhere,
                          llvm::SmallVectorImpl<AnyRequest> &visitedAlongPath,
-                         llvm::ArrayRef<AnyRequest> highlightPath,
+                         ArrayRef<AnyRequest> highlightPath,
                          std::string &prefixStr,
                          bool lastChild) const;
 

include/swift/AST/SimpleRequest.h

@@ -130,8 +130,10 @@ class SimpleRequest {
   explicit SimpleRequest(const Inputs& ...inputs)
     : storage(inputs...) { }
 
-  OutputType operator()(Evaluator &evaluator) const {
-    return callDerived(evaluator, llvm::index_sequence_for<Inputs...>());
+  /// Request evaluation function that will be registered with the evaluator.
+  static OutputType evaluate(const Derived &request, Evaluator &evaluator) {
+    return request.callDerived(evaluator,
+                               llvm::index_sequence_for<Inputs...>());
   }
 
   void diagnoseCycle(DiagnosticEngine &diags) const {

include/swift/Basic/DefineTypeIDZone.h

@@ -46,15 +46,15 @@ template<> struct TypeIDZoneTypes<SWIFT_TYPEID_ZONE> {
 };
 
 // Second pass: create specializations of TypeID for these types.
-#define SWIFT_TYPEID_NAMED(Type, Name)                    \
-template<> struct TypeID<Type> {                          \
-  static const uint64_t value =                           \
-    formTypeID(SWIFT_TYPEID_ZONE,                         \
-               TypeIDZoneTypes<SWIFT_TYPEID_ZONE>::Name); \
-                                                          \
-  static llvm::StringRef getName() {                      \
-    return #Name;                                         \
-  }                                                       \
+#define SWIFT_TYPEID_NAMED(Type, Name)                       \
+template<> struct TypeID<Type> {                             \
+  static const uint8_t zoneID = SWIFT_TYPEID_ZONE;           \
+  static const uint8_t localID =                             \
+    TypeIDZoneTypes<SWIFT_TYPEID_ZONE>::Name;                \
+                                                             \
+  static const uint64_t value = formTypeID(zoneID, localID); \
+                                                             \
+  static llvm::StringRef getName() { return #Name; }         \
 };
 
 #define SWIFT_TYPEID_TEMPLATE1_NAMED(Template, Name, Param1, Arg1)    \

include/swift/Sema/TypeCheckRequests.h

@@ -46,7 +46,6 @@ class InheritedTypeRequest :
 
 public:
   using SimpleRequest::SimpleRequest;
-  using SimpleRequest::operator();
 
 private:
   friend class SimpleRequest;
@@ -76,7 +75,6 @@ class SuperclassTypeRequest :
                          NominalTypeDecl *> {
 public:
   using SimpleRequest::SimpleRequest;
-  using SimpleRequest::operator();
 
 private:
   friend class SimpleRequest;
@@ -104,7 +102,6 @@ class EnumRawTypeRequest :
                          EnumDecl *> {
 public:
   using SimpleRequest::SimpleRequest;
-  using SimpleRequest::operator();
 
 private:
   friend class SimpleRequest;
@@ -124,7 +121,10 @@ class EnumRawTypeRequest :
   void cacheResult(Type value) const;
 };
 
-#define SWIFT_TYPEID_ZONE 10
+/// The zone number for the type checker.
+#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"
 #include "swift/Basic/DefineTypeIDZone.h"
 

include/swift/Sema/TypeCheckerTypeIDZone.def

@@ -1,4 +1,4 @@
-//===--- ArithmeticEvaluatorTypeIDZone.def - --------------------*- C++ -*-===//
+//===--- TypeCheckerTypeIDZone.def ------------------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //

include/swift/Subsystems.h

@@ -46,6 +46,7 @@ namespace swift {
   class DelayedParsingCallbacks;
   class DiagnosticConsumer;
   class DiagnosticEngine;
+  class Evaluator;
   class FileUnit;
   class GenericEnvironment;
   class GenericParamList;
@@ -342,6 +343,13 @@ namespace swift {
     struct Implementation;
     Implementation &Impl;
   };
+
+  /// Register the type checker's request functions with the evaluator.
+  ///
+  /// Clients that form an ASTContext and will perform any semantic
+  /// queries should call this function after forming the ASTContext.
+  void registerTypeCheckerRequestFunctions(Evaluator &evaluator);
+
 } // end namespace swift
 
 #endif // SWIFT_SUBSYSTEMS_H

lib/AST/Evaluator.cpp

@@ -32,6 +32,32 @@ std::string AnyRequest::getAsString() const {
   return result;
 }
 
+AbstractRequestFunction *
+Evaluator::getAbstractRequestFunction(uint8_t zoneID, uint8_t requestID) const {
+  for (const auto &zone : requestFunctionsByZone) {
+    if (zone.first == zoneID) {
+      if (requestID < zone.second.size())
+        return zone.second[requestID];
+
+      return nullptr;
+    }
+  }
+
+  return nullptr;
+}
+
+void Evaluator::registerRequestFunctions(
+                               uint8_t zoneID,
+                               ArrayRef<AbstractRequestFunction *> functions) {
+#ifndef NDEBUG
+  for (const auto &zone : requestFunctionsByZone) {
+    assert(zone.first != zoneID);
+  }
+#endif
+
+  requestFunctionsByZone.push_back({zoneID, functions});
+}
+
 Evaluator::Evaluator(DiagnosticEngine &diags,
                      CycleDiagnosticKind shouldDiagnoseCycles)
   : diags(diags), shouldDiagnoseCycles(shouldDiagnoseCycles) { }

lib/Frontend/Frontend.cpp

@@ -152,6 +152,7 @@ bool CompilerInstance::setup(const CompilerInvocation &Invok) {
   Context.reset(ASTContext::get(Invocation.getLangOptions(),
                                 Invocation.getSearchPathOptions(), SourceMgr,
                                 Diagnostics));
+  registerTypeCheckerRequestFunctions(Context->evaluator);
 
   if (setUpModuleLoaders())
     return true;

lib/Sema/TypeCheckRequests.cpp

@@ -16,6 +16,8 @@
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/Types.h"
+#include "swift/Subsystems.h"
+
 using namespace swift;
 
 namespace swift {
@@ -265,3 +267,16 @@ 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::evaluate),
+#include "swift/Sema/TypeCheckerTypeIDZone.def"
+#undef SWIFT_TYPEID
+};
+
+void swift::registerTypeCheckerRequestFunctions(Evaluator &evaluator) {
+  evaluator.registerRequestFunctions(SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE,
+                                     typeCheckerRequestFunctions);
+}

tools/driver/modulewrap_main.cpp

@@ -171,6 +171,8 @@ int modulewrap_main(ArrayRef<const char *> Args, const char *Argv0,
   LangOpts.Target = Invocation.getTargetTriple();
   ASTContext &ASTCtx = *ASTContext::get(LangOpts, SearchPathOpts, SrcMgr,
                                         Instance.getDiags());
+  registerTypeCheckerRequestFunctions(ASTCtx.evaluator);
+  
   ClangImporterOptions ClangImporterOpts;
   ASTCtx.addModuleLoader(ClangImporter::create(ASTCtx, ClangImporterOpts, ""),
                          true);

unittests/AST/ArithmeticEvaluator.cpp

@@ -87,7 +87,6 @@ struct EvaluationRule
   : public SimpleRequest<Derived, Caching, double, ArithmeticExpr *>
 {
   using SimpleRequest<Derived, Caching, double, ArithmeticExpr *>::SimpleRequest;
-  using SimpleRequest<Derived, Caching, double, ArithmeticExpr *>::operator();
 
   double operator()(Evaluator &evaluator, ArithmeticExpr *expr) const {
     switch (expr->kind) {
@@ -179,16 +178,25 @@ struct ExternallyCachedEvaluationRule
 
 // Define the arithmetic evaluator's zone.
 namespace swift {
-#define SWIFT_TYPEID_ZONE 255
+#define SWIFT_ARITHMETIC_EVALUATOR_ZONE 255
+#define SWIFT_TYPEID_ZONE SWIFT_ARITHMETIC_EVALUATOR_ZONE
 #define SWIFT_TYPEID_HEADER "ArithmeticEvaluatorTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"
 
-#define SWIFT_TYPEID_ZONE 255
+#define SWIFT_TYPEID_ZONE SWIFT_ARITHMETIC_EVALUATOR_ZONE
 #define SWIFT_TYPEID_HEADER "ArithmeticEvaluatorTypeIDZone.def"
 #include "swift/Basic/ImplementTypeIDZone.h"
 
 }
 
+/// All of the arithmetic request functions.
+static AbstractRequestFunction *arithmeticRequestFunctions[] = {
+#define SWIFT_TYPEID(Name)                                    \
+  reinterpret_cast<AbstractRequestFunction *>(&Name::evaluate),
+#include "ArithmeticEvaluatorTypeIDZone.def"
+#undef SWIFT_TYPEID
+};
+
 TEST(ArithmeticEvaluator, Simple) {
   // (3.14159 + 2.71828) * 42
   ArithmeticExpr *pi = new Literal(3.14159);
@@ -201,6 +209,8 @@ TEST(ArithmeticEvaluator, Simple) {
   SourceManager sourceMgr;
   DiagnosticEngine diags(sourceMgr);
   Evaluator evaluator(diags, CycleDiagnosticKind::FullDiagnose);
+  evaluator.registerRequestFunctions(SWIFT_ARITHMETIC_EVALUATOR_ZONE,
+                                     arithmeticRequestFunctions);
 
   const double expectedResult = (3.14159 + 2.71828) * 42.0;
   EXPECT_EQ(evaluator(InternallyCachedEvaluationRule(product)),
@@ -321,6 +331,8 @@ TEST(ArithmeticEvaluator, Cycle) {
   SourceManager sourceMgr;
   DiagnosticEngine diags(sourceMgr);
   Evaluator evaluator(diags, CycleDiagnosticKind::FullDiagnose);
+  evaluator.registerRequestFunctions(SWIFT_ARITHMETIC_EVALUATOR_ZONE,
+                                     arithmeticRequestFunctions);
 
   // Evaluate when there is a cycle.
   UncachedEvaluationRule::brokeCycle = false;