NFC: Pass through an ASTContext to IsSingleValueStmtRequest

Author: hamishknight

include/swift/AST/Stmt.h

@@ -144,7 +144,6 @@ class alignas(8) Stmt : public ASTAllocated<Stmt> {
 
   /// Whether the statement can produce a single value, and as such may be
   /// treated as an expression.
-  IsSingleValueStmtResult mayProduceSingleValue(Evaluator &eval) const;
   IsSingleValueStmtResult mayProduceSingleValue(ASTContext &ctx) const;
 
   /// isImplicit - Determines whether this statement was implicitly-generated,

include/swift/AST/TypeCheckRequests.h

@@ -3997,18 +3997,21 @@ class IsSingleValueStmtResult {
 };
 
 /// Computes whether a given statement can be treated as a SingleValueStmtExpr.
+///
+// TODO: We ought to consider storing a reference to the ASTContext on the
+// evaluator.
 class IsSingleValueStmtRequest
     : public SimpleRequest<IsSingleValueStmtRequest,
-                           IsSingleValueStmtResult(const Stmt *),
+                           IsSingleValueStmtResult(const Stmt *, ASTContext *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  IsSingleValueStmtResult
-  evaluate(Evaluator &evaluator, const Stmt *stmt) const;
+  IsSingleValueStmtResult evaluate(Evaluator &evaluator, const Stmt *stmt,
+                                   ASTContext *ctx) const;
 
 public:
   bool isCached() const { return true; }

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -443,7 +443,7 @@ SWIFT_REQUEST(TypeChecker, PreCheckReturnStmtRequest,
               Stmt *(ReturnStmt *, DeclContext *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsSingleValueStmtRequest,
-              IsSingleValueStmtResult(const Stmt *),
+              IsSingleValueStmtResult(const Stmt *, ASTContext *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
               MacroDefinition(MacroDecl *),

lib/AST/Stmt.cpp

@@ -333,13 +333,9 @@ Stmt *BraceStmt::getSingleActiveStatement() const {
   return getSingleActiveElement().dyn_cast<Stmt *>();
 }
 
-IsSingleValueStmtResult Stmt::mayProduceSingleValue(Evaluator &eval) const {
-  return evaluateOrDefault(eval, IsSingleValueStmtRequest{this},
-                           IsSingleValueStmtResult::circularReference());
-}
-
 IsSingleValueStmtResult Stmt::mayProduceSingleValue(ASTContext &ctx) const {
-  return mayProduceSingleValue(ctx.evaluator);
+  return evaluateOrDefault(ctx.evaluator, IsSingleValueStmtRequest{this, &ctx},
+                           IsSingleValueStmtResult::circularReference());
 }
 
 SourceLoc ReturnStmt::getStartLoc() const {

lib/Sema/TypeCheckStmt.cpp

@@ -2669,7 +2669,7 @@ PreCheckFunctionBodyRequest::evaluate(Evaluator &evaluator,
     // single expression return, do so now.
     if (!func->getResultInterfaceType()->isVoid()) {
       if (auto *S = body->getSingleActiveStatement()) {
-        if (S->mayProduceSingleValue(evaluator)) {
+        if (S->mayProduceSingleValue(ctx)) {
           auto *SVE = SingleValueStmtExpr::createWithWrappedBranches(
               ctx, S, /*DC*/ func, /*mustBeExpr*/ false);
           auto *RS = new (ctx) ReturnStmt(SourceLoc(), SVE);
@@ -2914,7 +2914,7 @@ static bool doesBraceEndWithThrow(BraceStmt *BS) {
 
 /// Whether the given brace statement is considered to produce a result for
 /// an if/switch expression.
-static bool doesBraceProduceResult(BraceStmt *BS, Evaluator &eval) {
+static bool doesBraceProduceResult(BraceStmt *BS, ASTContext &ctx) {
   if (BS->empty())
     return false;
 
@@ -2926,14 +2926,14 @@ static bool doesBraceProduceResult(BraceStmt *BS, Evaluator &eval) {
     return true;
 
   if (auto *S = BS->getSingleActiveStatement()) {
-    if (S->mayProduceSingleValue(eval))
+    if (S->mayProduceSingleValue(ctx))
       return true;
   }
   return SingleValueStmtExpr::hasResult(BS);
 }
 
 IsSingleValueStmtResult
-areBranchesValidForSingleValueStmt(Evaluator &eval, ArrayRef<Stmt *> branches) {
+areBranchesValidForSingleValueStmt(ASTContext &ctx, ArrayRef<Stmt *> branches) {
   TinyPtrVector<Stmt *> invalidJumps;
   TinyPtrVector<Stmt *> unterminatedBranches;
   JumpOutOfContextFinder jumpFinder(invalidJumps);
@@ -2950,7 +2950,7 @@ areBranchesValidForSingleValueStmt(Evaluator &eval, ArrayRef<Stmt *> branches) {
     BS->walk(jumpFinder);
 
     // Check to see if a result is produced from the branch.
-    if (doesBraceProduceResult(BS, eval)) {
+    if (doesBraceProduceResult(BS, ctx)) {
       hadResult = true;
       continue;
     }
@@ -2976,7 +2976,11 @@ areBranchesValidForSingleValueStmt(Evaluator &eval, ArrayRef<Stmt *> branches) {
 }
 
 IsSingleValueStmtResult
-IsSingleValueStmtRequest::evaluate(Evaluator &eval, const Stmt *S) const {
+IsSingleValueStmtRequest::evaluate(Evaluator &eval, const Stmt *S,
+                                   ASTContext *_ctx) const {
+  assert(_ctx);
+  auto &ctx = *_ctx;
+
   if (!isa<IfStmt>(S) && !isa<SwitchStmt>(S))
     return IsSingleValueStmtResult::unhandledStmt();
 
@@ -2991,11 +2995,11 @@ IsSingleValueStmtRequest::evaluate(Evaluator &eval, const Stmt *S) const {
       return IsSingleValueStmtResult::nonExhaustiveIf();
 
     SmallVector<Stmt *, 4> scratch;
-    return areBranchesValidForSingleValueStmt(eval, IS->getBranches(scratch));
+    return areBranchesValidForSingleValueStmt(ctx, IS->getBranches(scratch));
   }
   if (auto *SS = dyn_cast<SwitchStmt>(S)) {
     SmallVector<Stmt *, 4> scratch;
-    return areBranchesValidForSingleValueStmt(eval, SS->getBranches(scratch));
+    return areBranchesValidForSingleValueStmt(ctx, SS->getBranches(scratch));
   }
   llvm_unreachable("Unhandled case");
 }