AST: Look for cached request result before checking for a cycle

This improves performance in the common case where the result has
already been cached, because the cycle check constructs an
AnyRequest existential, which is expensive.

Author: slavapestov

include/swift/AST/Evaluator.h

@@ -258,26 +258,28 @@ class Evaluator {
   void registerRequestFunctions(Zone zone,
                                 ArrayRef<AbstractRequestFunction *> functions);
 
-  /// Evaluate the given request and produce its result,
-  /// consulting/populating the cache as required.
-  template<typename Request>
+  /// Retrieve the result produced by evaluating a request that can
+  /// be cached.
+  template<typename Request,
+           typename std::enable_if<Request::isEverCached>::type * = nullptr>
   llvm::Expected<typename Request::OutputType>
   operator()(const Request &request) {
-    // Check for a cycle.
-    if (checkDependency(getCanonicalRequest(request))) {
-      return llvm::Error(
-        llvm::make_unique<CyclicalRequestError<Request>>(request, *this));
-    }
+    // The request can be cached, but check a predicate to determine
+    // whether this particular instance is cached. This allows more
+    // fine-grained control over which instances get cache.
+    if (request.isCached())
+      return getResultCached(request);
 
-    // Make sure we remove this from the set of active requests once we're
-    // done.
-    SWIFT_DEFER {
-      assert(activeRequests.back().castTo<Request>() == request);
-      activeRequests.pop_back();
-    };
+    return getResultUncached(request);
+  }
 
-    // Get the result.
-    return getResult(request);
+  /// Retrieve the result produced by evaluating a request that
+  /// will never be cached.
+  template<typename Request,
+           typename std::enable_if<!Request::isEverCached>::type * = nullptr>
+  llvm::Expected<typename Request::OutputType>
+  operator()(const Request &request) {
+    return getResultUncached(request);
   }
 
   /// Evaluate a set of requests and return their results as a tuple.
@@ -345,34 +347,23 @@ class Evaluator {
   /// request to the \c activeRequests stack.
   bool checkDependency(const AnyRequest &request);
 
-  /// Retrieve the result produced by evaluating a request that can
-  /// be cached.
-  template<typename Request,
-           typename std::enable_if<Request::isEverCached>::type * = nullptr>
-  llvm::Expected<typename Request::OutputType>
-  getResult(const Request &request) {
-    // The request can be cached, but check a predicate to determine
-    // whether this particular instance is cached. This allows more
-    // fine-grained control over which instances get cache.
-    if (request.isCached())
-      return getResultCached(request);
-
-    return getResultUncached(request);
-  }
-
-  /// Retrieve the result produced by evaluating a request that
-  /// will never be cached.
-  template<typename Request,
-           typename std::enable_if<!Request::isEverCached>::type * = nullptr>
-  llvm::Expected<typename Request::OutputType>
-  getResult(const Request &request) {
-    return getResultUncached(request);
-  }
-
   /// Produce the result of the request without caching.
   template<typename Request>
   llvm::Expected<typename Request::OutputType>
   getResultUncached(const Request &request) {
+    // Check for a cycle.
+    if (checkDependency(getCanonicalRequest(request))) {
+      return llvm::Error(
+        llvm::make_unique<CyclicalRequestError<Request>>(request, *this));
+    }
+
+    // Make sure we remove this from the set of active requests once we're
+    // done.
+    SWIFT_DEFER {
+      assert(activeRequests.back().castTo<Request>() == request);
+      activeRequests.pop_back();
+    };
+
     // Clear out the dependencies on this request; we're going to recompute
     // them now anyway.
     if (buildDependencyGraph)