[Evaluator] Rename request’s operator() to evaluate() to make it more clear.

Author: DougGregor

include/swift/AST/SimpleRequest.h

@@ -56,7 +56,7 @@ enum class CacheKind {
 /// important one takes an evaluator and the input values, then computes the
 /// final result:
 /// \code
-///   Output operator()(Evaluator &evaluator, Inputs...) const;
+///   Output evaluate(Evaluator &evaluator, Inputs...) const;
 /// \endcode
 ///
 /// The \c Derived class will also need to implement an operation to break a
@@ -105,8 +105,8 @@ class SimpleRequest {
   template<size_t ...Indices>
   Output callDerived(Evaluator &evaluator,
                      llvm::index_sequence<Indices...>) const {
-    static_assert(sizeof...(Indices) > 0, "Subclass must define operator()");
-    return asDerived()(evaluator, std::get<Indices>(storage)...);
+    static_assert(sizeof...(Indices) > 0, "Subclass must define evaluate()");
+    return asDerived().evaluate(evaluator, std::get<Indices>(storage)...);
   }
 
   template<size_t ...Indices>
@@ -131,7 +131,8 @@ class SimpleRequest {
     : storage(inputs...) { }
 
   /// Request evaluation function that will be registered with the evaluator.
-  static OutputType evaluate(const Derived &request, Evaluator &evaluator) {
+  static OutputType evaluateRequest(const Derived &request,
+                                    Evaluator &evaluator) {
     return request.callDerived(evaluator,
                                llvm::index_sequence_for<Inputs...>());
   }

include/swift/Sema/TypeCheckRequests.h

@@ -51,9 +51,9 @@ class InheritedTypeRequest :
   friend class SimpleRequest;
 
   // Evaluation.
-  Type operator()(Evaluator &evaluator,
-                  llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
-                  unsigned index) const;
+  Type evaluate(Evaluator &evaluator,
+                llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
+                unsigned index) const;
 
 public:
   // Cycle handling
@@ -80,7 +80,7 @@ class SuperclassTypeRequest :
   friend class SimpleRequest;
 
   // Evaluation.
-  Type operator()(Evaluator &evaluator, NominalTypeDecl *classDecl) const;
+  Type evaluate(Evaluator &evaluator, NominalTypeDecl *classDecl) const;
 
 public:
   // Cycle handling
@@ -107,7 +107,7 @@ class EnumRawTypeRequest :
   friend class SimpleRequest;
 
   // Evaluation.
-  Type operator()(Evaluator &evaluator, EnumDecl *enumDecl) const;
+  Type evaluate(Evaluator &evaluator, EnumDecl *enumDecl) const;
 
 public:
   // Cycle handling

lib/Sema/TypeCheckRequests.cpp

@@ -54,7 +54,7 @@ TypeLoc &InheritedTypeRequest::getTypeLoc(
   return decl.get<ExtensionDecl *>()->getInherited()[index];
 }
 
-Type InheritedTypeRequest::operator()(
+Type InheritedTypeRequest::evaluate(
                         Evaluator &evaluator,
                         llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl,
                         unsigned index) const {
@@ -149,8 +149,8 @@ void InheritedTypeRequest::cacheResult(Type value) const {
 //----------------------------------------------------------------------------//
 // Superclass computation.
 //----------------------------------------------------------------------------//
-Type SuperclassTypeRequest::operator()(Evaluator &evaluator,
-                                       NominalTypeDecl *nominalDecl) const {
+Type SuperclassTypeRequest::evaluate(Evaluator &evaluator,
+                                     NominalTypeDecl *nominalDecl) const {
   assert(isa<ClassDecl>(nominalDecl) || isa<ProtocolDecl>(nominalDecl));
 
   for (unsigned int idx : indices(nominalDecl->getInherited())) {
@@ -223,8 +223,8 @@ void SuperclassTypeRequest::cacheResult(Type value) const {
 //----------------------------------------------------------------------------//
 // Enum raw type computation.
 //----------------------------------------------------------------------------//
-Type EnumRawTypeRequest::operator()(Evaluator &evaluator,
-                                    EnumDecl *enumDecl) const {
+Type EnumRawTypeRequest::evaluate(Evaluator &evaluator,
+                                  EnumDecl *enumDecl) const {
   for (unsigned int idx : indices(enumDecl->getInherited())) {
     Type inheritedType = evaluator(InheritedTypeRequest{enumDecl, idx});
     if (!inheritedType) continue;
@@ -271,7 +271,7 @@ void EnumRawTypeRequest::cacheResult(Type value) const {
 // Define request evaluation functions for each of the type checker requests.
 static AbstractRequestFunction *typeCheckerRequestFunctions[] = {
 #define SWIFT_TYPEID(Name)                                    \
-  reinterpret_cast<AbstractRequestFunction *>(&Name::evaluate),
+  reinterpret_cast<AbstractRequestFunction *>(&Name::evaluateRequest),
 #include "swift/Sema/TypeCheckerTypeIDZone.def"
 #undef SWIFT_TYPEID
 };

unittests/AST/ArithmeticEvaluator.cpp

@@ -88,7 +88,7 @@ struct EvaluationRule
 {
   using SimpleRequest<Derived, Caching, double, ArithmeticExpr *>::SimpleRequest;
 
-  double operator()(Evaluator &evaluator, ArithmeticExpr *expr) const {
+  double evaluate(Evaluator &evaluator, ArithmeticExpr *expr) const {
     switch (expr->kind) {
     case ArithmeticExpr::Kind::Literal:
       return static_cast<Literal *>(expr)->value;
@@ -192,7 +192,7 @@ namespace swift {
 /// All of the arithmetic request functions.
 static AbstractRequestFunction *arithmeticRequestFunctions[] = {
 #define SWIFT_TYPEID(Name)                                    \
-  reinterpret_cast<AbstractRequestFunction *>(&Name::evaluate),
+  reinterpret_cast<AbstractRequestFunction *>(&Name::evaluateRequest),
 #include "ArithmeticEvaluatorTypeIDZone.def"
 #undef SWIFT_TYPEID
 };