[NFC] Remove SourceFile's Operator Lookup Entrypoints

Now that this is requestified, the extra level of indirection serves no
purpose.

Author: CodaFi

include/swift/AST/SourceFile.h

@@ -461,25 +461,6 @@ class SourceFile final : public FileUnit {
 
   virtual bool walk(ASTWalker &walker) override;
 
-  /// @{
-
-  /// Look up the given operator in this file.
-  ///
-  /// The file must be name-bound already. If the operator is not found, or if
-  /// there is an ambiguity, returns null.
-  ///
-  /// \param isCascading If true, the lookup of this operator may affect
-  /// downstream files.
-  InfixOperatorDecl *lookupInfixOperator(Identifier name, bool isCascading,
-                                         SourceLoc diagLoc = {});
-  PrefixOperatorDecl *lookupPrefixOperator(Identifier name, bool isCascading,
-                                           SourceLoc diagLoc = {});
-  PostfixOperatorDecl *lookupPostfixOperator(Identifier name, bool isCascading,
-                                             SourceLoc diagLoc = {});
-  PrecedenceGroupDecl *lookupPrecedenceGroup(Identifier name, bool isCascading,
-                                             SourceLoc diagLoc = {});
-  /// @}
-
   ReferencedNameTracker *getReferencedNameTracker() {
     return ReferencedNames ? ReferencedNames.getPointer() : nullptr;
   }

lib/AST/Module.cpp

@@ -1186,12 +1186,6 @@ llvm::Expected<OperatorType *> LookupOperatorRequest<OperatorType>::evaluate(
         lookupOperatorDeclForName(this, loc, name, &SourceFile::Kind##s);      \
     return result ? *result : nullptr;                                         \
   }                                                                            \
-  Kind##Decl *SourceFile::lookup##Kind(Identifier name, bool cascades,         \
-                                       SourceLoc loc) {                        \
-    return evaluateOrDefault(                                                  \
-        getASTContext().evaluator,                                             \
-        Lookup##Kind##Request{{this, name, cascades, loc}}, nullptr);          \
-  }                                                                            \
   template llvm::Expected<Kind##Decl *>                                        \
   LookupOperatorRequest<Kind##Decl>::evaluate(Evaluator &e,                    \
                                               OperatorLookupDescriptor d) const;

lib/Sema/TypeCheckDecl.cpp

@@ -1253,9 +1253,14 @@ static PrecedenceGroupDecl *
 lookupPrecedenceGroup(const PrecedenceGroupDescriptor &descriptor) {
   auto *dc = descriptor.dc;
   if (auto sf = dc->getParentSourceFile()) {
-    bool cascading = dc->isCascadingContextForLookup(false);
-    return sf->lookupPrecedenceGroup(descriptor.ident, cascading,
-                                     descriptor.nameLoc);
+    OperatorLookupDescriptor desc{
+      sf,
+      descriptor.ident,
+      dc->isCascadingContextForLookup(false),
+      descriptor.nameLoc
+    };
+    return evaluateOrDefault(sf->getASTContext().evaluator,
+                             LookupPrecedenceGroupRequest{desc}, nullptr);
   } else {
     return dc->getParentModule()->lookupPrecedenceGroup(descriptor.ident,
                                                         descriptor.nameLoc);
@@ -1725,26 +1730,27 @@ FunctionOperatorRequest::evaluate(Evaluator &evaluator, FuncDecl *FD) const {
     FD->diagnose(diag::operator_in_local_scope);
   }
 
+  OperatorLookupDescriptor desc{
+    FD->getDeclContext()->getParentSourceFile(),
+    operatorName,
+    FD->isCascadingContextForLookup(false),
+    FD->getLoc()
+  };
   OperatorDecl *op = nullptr;
-  SourceFile &SF = *FD->getDeclContext()->getParentSourceFile();
   if (FD->isUnaryOperator()) {
     if (FD->getAttrs().hasAttribute<PrefixAttr>()) {
-      op = SF.lookupPrefixOperator(operatorName,
-                                   FD->isCascadingContextForLookup(false),
-                                   FD->getLoc());
+      op = evaluateOrDefault(evaluator,
+                             LookupPrefixOperatorRequest{desc}, nullptr);
     } else if (FD->getAttrs().hasAttribute<PostfixAttr>()) {
-      op = SF.lookupPostfixOperator(operatorName,
-                                    FD->isCascadingContextForLookup(false),
-                                    FD->getLoc());
+      op = evaluateOrDefault(evaluator,
+                             LookupPostfixOperatorRequest{desc}, nullptr);
     } else {
-      auto prefixOp =
-          SF.lookupPrefixOperator(operatorName,
-                                  FD->isCascadingContextForLookup(false),
-                                  FD->getLoc());
-      auto postfixOp =
-          SF.lookupPostfixOperator(operatorName,
-                                   FD->isCascadingContextForLookup(false),
-                                   FD->getLoc());
+      auto prefixOp = evaluateOrDefault(evaluator,
+                                        LookupPrefixOperatorRequest{desc},
+                                        nullptr);
+      auto postfixOp = evaluateOrDefault(evaluator,
+                                         LookupPostfixOperatorRequest{desc},
+                                         nullptr);
 
       // If we found both prefix and postfix, or neither prefix nor postfix,
       // complain. We can't fix this situation.
@@ -1790,9 +1796,9 @@ FunctionOperatorRequest::evaluate(Evaluator &evaluator, FuncDecl *FD) const {
                   static_cast<bool>(postfixOp));
     }
   } else if (FD->isBinaryOperator()) {
-    op = SF.lookupInfixOperator(operatorName,
-                                FD->isCascadingContextForLookup(false),
-                                FD->getLoc());
+    op = evaluateOrDefault(evaluator,
+                           LookupInfixOperatorRequest{desc},
+                           nullptr);
   } else {
     diags.diagnose(FD, diag::invalid_arg_count_for_operator);
     return nullptr;

lib/Sema/TypeCheckExpr.cpp

@@ -17,6 +17,7 @@
 
 #include "TypeChecker.h"
 #include "swift/AST/NameLookup.h"
+#include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/ParameterList.h"
@@ -129,12 +130,19 @@ Expr *TypeChecker::substituteInputSugarTypeForResult(ApplyExpr *E) {
 static PrecedenceGroupDecl *lookupPrecedenceGroupForOperator(DeclContext *DC,
                                                              Identifier name,
                                                              SourceLoc loc) {
-  SourceFile *SF = DC->getParentSourceFile();
-  bool isCascading = DC->isCascadingContextForLookup(true);
-  if (auto op = SF->lookupInfixOperator(name, isCascading, loc)) {
+  OperatorLookupDescriptor desc{
+    DC->getParentSourceFile(),
+    name,
+    DC->isCascadingContextForLookup(true),
+    loc
+  };
+  auto &Ctx = DC->getASTContext();
+  if (auto op = evaluateOrDefault(Ctx.evaluator,
+                                  LookupInfixOperatorRequest{desc},
+                                  nullptr)) {
     return op->getPrecedenceGroup();
   } else {
-    DC->getASTContext().Diags.diagnose(loc, diag::unknown_binop);
+    Ctx.Diags.diagnose(loc, diag::unknown_binop);
   }
   return nullptr;
 }