AST: Convert some methods on DependencyRecorder to templates

... instead of passing around an ActiveRequest.

Author: slavapestov

include/swift/AST/Evaluator.h

@@ -373,21 +373,21 @@ class Evaluator {
     FrontendStatsTracer statsTracer = make_tracer(stats, request);
     if (stats) reportEvaluatedRequest(*stats, request);
 
-    recorder.beginRequest(activeReq);
+    recorder.beginRequest<Request>();
 
-    auto &&r = getRequestFunction<Request>()(request, *this);
+    auto &&result = getRequestFunction<Request>()(request, *this);
 
-    recorder.endRequest(activeReq);
+    recorder.endRequest<Request>(request);
 
     handleDependencySourceRequest<Request>(request);
-    handleDependencySinkRequest<Request>(request, r);
+    handleDependencySinkRequest<Request>(request, result);
 
     // Make sure we remove this from the set of active requests once we're
     // done.
     assert(activeRequests.back() == activeReq);
     activeRequests.pop_back();
 
-    return std::move(r);
+    return std::move(result);
   }
 
   /// Get the result of a request, consulting an external cache
@@ -399,7 +399,7 @@ class Evaluator {
   getResultCached(const Request &request) {
     // If there is a cached result, return it.
     if (auto cached = request.getCachedResult()) {
-      recorder.replayCachedRequest(ActiveRequest(request));
+      recorder.replayCachedRequest(request);
       handleDependencySinkRequest<Request>(request, *cached);
       return *cached;
     }
@@ -428,7 +428,7 @@ class Evaluator {
     auto known = cache.find_as<Request>(request);
     if (known != cache.end<Request>()) {
       auto result = known->second;
-      recorder.replayCachedRequest(ActiveRequest(request));
+      recorder.replayCachedRequest(request);
       handleDependencySinkRequest<Request>(request, result);
       return result;
     }
@@ -466,7 +466,7 @@ class Evaluator {
   void handleDependencySourceRequest(const Request &r) {
     auto source = r.readDependencySource(recorder);
     if (!source.isNull() && source.get()->isPrimary()) {
-      recorder.handleDependencySourceRequest(ActiveRequest(r), source.get());
+      recorder.handleDependencySourceRequest(r, source.get());
     }
   }
 

include/swift/AST/EvaluatorDependencies.h

@@ -83,20 +83,24 @@ struct DependencyRecorder {
 
 public:
   /// Push a new empty set onto the activeRequestReferences stack.
-  void beginRequest(const swift::ActiveRequest &req);
+  template<typename Request>
+  void beginRequest();
 
   /// Pop the activeRequestReferences stack, and insert recorded references
   /// into the requestReferences map, as well as the next innermost entry in
   /// activeRequestReferences.
-  void endRequest(const swift::ActiveRequest &req);
+  template<typename Request>
+  void endRequest(const Request &req);
 
   /// When replaying a request whose value has already been cached, we need
   /// to update the innermost set in the activeRequestReferences stack.
-  void replayCachedRequest(const swift::ActiveRequest &req);
+  template<typename Request>
+  void replayCachedRequest(const Request &req);
 
   /// Upon completion of a dependency source request, we update the
   /// fileReferences map.
-  void handleDependencySourceRequest(const swift::ActiveRequest &req,
+  template<typename Request>
+  void handleDependencySourceRequest(const Request &req,
                                      SourceFile *source);
 
 private:
@@ -120,6 +124,70 @@ struct DependencyRecorder {
   void enumerateReferencesInFile(const SourceFile *SF,
                                  ReferenceEnumerator f) const ;
 };
+
+template<typename Request>
+void evaluator::DependencyRecorder::beginRequest() {
+  if (!Request::isEverCached && !Request::isDependencySource)
+    return;
+
+  activeRequestReferences.push_back({});
+}
+
+template<typename Request>
+void evaluator::DependencyRecorder::endRequest(const Request &req) {
+  if (!Request::isEverCached && !Request::isDependencySource)
+    return;
+
+  // Grab all the dependencies we've recorded so far, and pop
+  // the stack.
+  auto recorded = std::move(activeRequestReferences.back());
+  activeRequestReferences.pop_back();
+
+  // If we didn't record anything, there is nothing to do.
+  if (recorded.empty())
+    return;
+
+  // Convert the set of dependencies into a vector.
+  std::vector<DependencyCollector::Reference>
+      vec(recorded.begin(), recorded.end());
+
+  // The recorded dependencies bubble up to the parent request.
+  if (!activeRequestReferences.empty()) {
+    activeRequestReferences.back().insert(vec.begin(),
+                                          vec.end());
+  }
+
+  // Finally, record the dependencies so we can replay them
+  // later when the request is re-evaluated.
+  requestReferences.insert({AnyRequest(req), std::move(vec)});
+}
+
+template<typename Request>
+void evaluator::DependencyRecorder::replayCachedRequest(const Request &req) {
+  assert(req.isCached());
+
+  if (activeRequestReferences.empty())
+    return;
+
+  auto found = requestReferences.find_as(req);
+  if (found == requestReferences.end())
+    return;
+
+  activeRequestReferences.back().insert(found->second.begin(),
+                                        found->second.end());
+}
+
+template<typename Request>
+void evaluator::DependencyRecorder::handleDependencySourceRequest(
+    const Request &req,
+    SourceFile *source) {
+  auto found = requestReferences.find_as(req);
+  if (found != requestReferences.end()) {
+    fileReferences[source].insert(found->second.begin(),
+                                  found->second.end());
+  }
+}
+
 } // end namespace evaluator
 
 } // end namespace swift

lib/AST/Evaluator.cpp

@@ -358,68 +358,6 @@ void Evaluator::dumpDependenciesGraphviz() const {
   printDependenciesGraphviz(llvm::dbgs());
 }
 
-void evaluator::DependencyRecorder::beginRequest(
-    const swift::ActiveRequest &req) {
-  if (!req.isCached() && !req.isDependencySource())
-    return;
-
-  activeRequestReferences.push_back({});
-}
-
-void evaluator::DependencyRecorder::endRequest(
-    const swift::ActiveRequest &req) {
-  if (!req.isCached() && !req.isDependencySource())
-    return;
-
-  // Grab all the dependencies we've recorded so far, and pop
-  // the stack.
-  auto recorded = std::move(activeRequestReferences.back());
-  activeRequestReferences.pop_back();
-
-  // If we didn't record anything, there is nothing to do.
-  if (recorded.empty())
-    return;
-
-  // Convert the set of dependencies into a vector.
-  std::vector<DependencyCollector::Reference>
-      vec(recorded.begin(), recorded.end());
-
-  // The recorded dependencies bubble up to the parent request.
-  if (!activeRequestReferences.empty()) {
-    activeRequestReferences.back().insert(vec.begin(),
-                                          vec.end());
-  }
-
-  // Finally, record the dependencies so we can replay them
-  // later when the request is re-evaluated.
-  requestReferences.insert({AnyRequest(req), vec});
-}
-
-void evaluator::DependencyRecorder::replayCachedRequest(
-    const swift::ActiveRequest &req) {
-  assert(req.isCached());
-
-  if (activeRequestReferences.empty())
-    return;
-
-  auto found = requestReferences.find_as(req);
-  if (found == requestReferences.end())
-    return;
-
-  activeRequestReferences.back().insert(found->second.begin(),
-                                        found->second.end());
-}
-
-void evaluator::DependencyRecorder::handleDependencySourceRequest(
-    const swift::ActiveRequest &req,
-    SourceFile *source) {
-  auto found = requestReferences.find_as(req);
-  if (found != requestReferences.end()) {
-    fileReferences[source].insert(found->second.begin(),
-                                  found->second.end());
-  }
-}
-
 void evaluator::DependencyRecorder::recordDependency(
     const DependencyCollector::Reference &ref) {
   if (activeRequestReferences.empty())