[Evaluator] Add a Caching template parameter to SimpleRequest.

Simplify the definition of new request kinds by pulling the parameterization
of caching logic into SimpleRequest itself, so that the caching-related
parts of the contract cannot easily be forgotten.

Author: DougGregor

include/swift/AST/SimpleRequest.h

@@ -29,45 +29,68 @@ namespace swift {
 
 class Evaluator;
 
+/// Describes how the result for a particular request will be cached.
+enum class CacheKind {
+  /// The result for a particular request should never be cached.
+  Uncached,
+  /// The result for a particular request should be cached within the
+  /// evaluator itself.
+  Cached,
+  /// The result of a particular request will be cached via some separate
+  /// mechanism, such as a mutable data structure.
+  SeparatelyCached,
+};
+
 /// CRTP base class that describes a request operation that takes values
 /// with the given input types (\c Inputs...) and produces an output of
 /// the given type.
 ///
 /// \tparam Derived The final, derived class type for the request.
+/// \tparam Caching Describes how the output value is cached, if at all.
 /// \tparam Output The type of the result produced by evaluating this request.
 /// \tparam Inputs The types of the inputs to this request, i.e., the values
 /// that comprise the request itself. These will determine the uniqueness of
 /// the request.
 ///
-/// The Derived class needs to implement several operations. The most important
-/// one takes an evaluator and the input values, then computes the final
-/// result:
+/// The \c Derived class needs to implement several operations. The most
+/// important one takes an evaluator and the input values, then computes the
+/// final result:
 /// \code
 ///   Output operator()(Evaluator &evaluator, Inputs...) const;
 /// \endcode
 ///
-/// The Derived class will also need to implement an operation to break a
+/// The \c Derived class will also need to implement an operation to break a
 /// cycle if one is found, i.e.,
 /// \code
 ///   OutputType breakCycle() const;
 /// \endcode
 ///
-/// Cycle diagnostics can be handled in one of two ways. Either the Derived
+/// Cycle diagnostics can be handled in one of two ways. Either the \c Derived
 /// class can implement the two cycle-diagnosing operations directly:
 /// \code
 ///   void diagnoseCycle(DiagnosticEngine &diags) const;
 ///   void noteCycleStep(DiagnosticEngine &diags) const;
 /// \endcode
 ///
-/// Or the Derived class can provide a "diagnostic location" operation and
+/// Or the \c Derived class can provide a "diagnostic location" operation and
 /// diagnostic values for the main cycle diagnostic and a "note" describing a
 /// step within the chain of diagnostics:
 /// \code
 ///   T getCycleDiagnosticLoc(Inputs...) const;
 ///   static constexpr Diag<Inputs...> cycleDiagnostic = ...;
 ///   static constexpr Diag<Inputs...> cycleStepDiagnostic = ...;
 /// \endcode
-template<typename Derived, typename Output, typename ...Inputs>
+///
+/// Value caching is determined by the \c Caching parameter. When
+/// \c Caching == CacheKind::SeparatelyCached, the \c Derived class is
+/// responsible for implementing the two operations responsible to managing
+/// the cache:
+/// \code
+///   Optional<Output> getCachedResult() const;
+///   void cacheResult(Output value) const;
+/// \endcode
+template<typename Derived, CacheKind Caching, typename Output,
+         typename ...Inputs>
 class SimpleRequest {
   std::tuple<Inputs...> storage;
 
@@ -99,6 +122,9 @@ class SimpleRequest {
   const std::tuple<Inputs...> &getStorage() const { return storage; }
 
 public:
+  static const bool isEverCached = (Caching != CacheKind::Uncached);
+  static const bool hasExternalCache = (Caching == CacheKind::SeparatelyCached);
+
   using OutputType = Output;
 
   explicit SimpleRequest(const Inputs& ...inputs)

unittests/AST/ArithmeticEvaluator.cpp

@@ -82,12 +82,12 @@ void simple_display(llvm::raw_ostream &out, ArithmeticExpr *expr) {
 }
 
 /// Rule to evaluate the value of the expression.
-template<typename Derived>
+template<typename Derived, CacheKind Caching>
 struct EvaluationRule
-  : public SimpleRequest<Derived, double, ArithmeticExpr *>
+  : public SimpleRequest<Derived, Caching, double, ArithmeticExpr *>
 {
-  using SimpleRequest<Derived, double, ArithmeticExpr *>::SimpleRequest;
-  using SimpleRequest<Derived, double, ArithmeticExpr *>::operator();
+  using SimpleRequest<Derived, Caching, double, ArithmeticExpr *>::SimpleRequest;
+  using SimpleRequest<Derived, Caching, double, ArithmeticExpr *>::operator();
 
   double operator()(Evaluator &evaluator, ArithmeticExpr *expr) const {
     switch (expr->kind) {
@@ -122,15 +122,12 @@ struct EvaluationRule
   void noteCycleStep(DiagnosticEngine &diags) const { }
 };
 
-template<typename Derived>
-bool EvaluationRule<Derived>::brokeCycle = false;
+template<typename Derived, CacheKind Caching>
+bool EvaluationRule<Derived, Caching>::brokeCycle = false;
 
 struct InternallyCachedEvaluationRule :
-  EvaluationRule<InternallyCachedEvaluationRule>
+EvaluationRule<InternallyCachedEvaluationRule, CacheKind::Cached>
 {
-  static const bool isEverCached = true;
-  static const bool hasExternalCache = false;
-
   using EvaluationRule::EvaluationRule;
 
   bool isCached() const {
@@ -145,17 +142,14 @@ struct InternallyCachedEvaluationRule :
   }
 };
 
-struct UncachedEvaluationRule : EvaluationRule<UncachedEvaluationRule> {
-  static const bool isEverCached = false;
-
+struct UncachedEvaluationRule
+    : EvaluationRule<UncachedEvaluationRule, CacheKind::Uncached> {
   using EvaluationRule::EvaluationRule;
 };
 
-struct ExternallyCachedEvaluationRule :
-  EvaluationRule<ExternallyCachedEvaluationRule> {
-  static const bool isEverCached = true;
-  static const bool hasExternalCache = true;
-
+struct ExternallyCachedEvaluationRule
+    : EvaluationRule<ExternallyCachedEvaluationRule,
+                     CacheKind::SeparatelyCached> {
   using EvaluationRule::EvaluationRule;
 
   bool isCached() const {