Basic: Introduce 'split caching' for requests

Author: slavapestov

include/swift/AST/Evaluator.h

@@ -271,6 +271,31 @@ class Evaluator {
     recorder.clearRequest<Request>(request);
   }
 
+  /// Store a value in the request evaluator's cache for a split-cached request.
+  /// The request chooses to do this itself for storing some suitable definition of
+  /// "non-empty" value.
+  template<typename Request,
+           typename std::enable_if<Request::hasSplitCache>::type* = nullptr>
+  void cacheNonEmptyOutput(const Request &request,
+                           typename Request::OutputType &&output) {
+    bool inserted = cache.insert<Request>(request, std::move(output));
+    assert(inserted && "Request result was already cached");
+    (void) inserted;
+  }
+
+  /// Consults the request evaluator's cache for a split-cached request.
+  /// The request should perform this check after consulting it's own optimized
+  /// representation for storing an empty value.
+  template<typename Request,
+           typename std::enable_if<Request::hasSplitCache>::type* = nullptr>
+  std::optional<typename Request::OutputType>
+  getCachedNonEmptyOutput(const Request &request) {
+    auto found = cache.find_as(request);
+    if (found == cache.end<Request>())
+      return std::nullopt;
+    return found->second;
+  }
+
   /// Clear the cache stored within this evaluator.
   ///
   /// Note that this does not clear the caches of requests that use external

include/swift/AST/SimpleRequest.h

@@ -36,12 +36,23 @@ class Evaluator;
 enum class RequestFlags {
   /// The result for a particular request should never be cached.
   Uncached = 1 << 0,
+
   /// The result for a particular request should be cached within the
   /// evaluator itself.
   Cached = 1 << 1,
+
   /// The result of a particular request will be cached via some separate
   /// mechanism, such as a mutable data structure.
   SeparatelyCached = 1 << 2,
+
+  /// The result is separately cached, but the request can also make use
+  /// of the request evaluator's cache for out-of-line storage. This
+  /// is used to optimize caching of requests where the usual case is
+  /// that the value is empty. In this case, the separate mechanism
+  /// can represent the empty state more efficiently than adding a new
+  /// entry to the request evaluator's cache.
+  SplitCached = 1 << 3,
+
   /// This request introduces the source component of a source-sink
   /// incremental dependency pair and defines a new dependency scope.
   ///
@@ -50,7 +61,7 @@ enum class RequestFlags {
   ///
   /// For further discussion on incremental dependencies
   /// see DependencyAnalysis.md.
-  DependencySource = 1 << 3,
+  DependencySource = 1 << 4,
   /// This request introduces the sink component of a source-sink
   /// incremental dependency pair and is a consumer of the current
   /// dependency scope.
@@ -60,7 +71,7 @@ enum class RequestFlags {
   ///
   /// For further discussion on incremental dependencies
   /// see DependencyAnalysis.md.
-  DependencySink = 1 << 4,
+  DependencySink = 1 << 5,
 };
 
 static constexpr inline RequestFlags operator|(RequestFlags lhs, RequestFlags rhs) {
@@ -167,6 +178,10 @@ constexpr bool hasExternalCache(RequestFlags kind) {
   return cacheContains(kind, RequestFlags::SeparatelyCached);
 }
 
+constexpr bool hasSplitCache(RequestFlags kind) {
+  return cacheContains(kind, RequestFlags::SplitCached);
+}
+
 constexpr bool isDependencySource(RequestFlags kind) {
   return cacheContains(kind, RequestFlags::DependencySource);
 }
@@ -279,6 +294,7 @@ class SimpleRequest<Derived, Output(Inputs...), Caching> {
 public:
   constexpr static bool isEverCached = detail::isEverCached(Caching);
   constexpr static bool hasExternalCache = detail::hasExternalCache(Caching);
+  constexpr static bool hasSplitCache = detail::hasSplitCache(Caching);
 
 public:
   constexpr static bool isDependencySource = detail::isDependencySource(Caching);