[NFC] Sema: Reimplement ReturnStmtFinder as a function with a callback

A callback enables the caller to control whether to abort the walk. This
is handy for `BraceHasExplicitReturnStmtRequest`.

Author: AnthonyLatsis

lib/Sema/BuilderTransform.cpp

@@ -1230,45 +1230,61 @@ void ConstraintSystem::removeResultBuilderTransform(AnyFunctionRef fn) {
   ASSERT(erased);
 }
 
-namespace {
-class ReturnStmtFinder : public ASTWalker {
-  std::vector<ReturnStmt *> ReturnStmts;
+/// Walks the given brace statement and calls the given function reference on
+/// every occurrence of an explicit `return` statement.
+///
+/// \param callback A function reference that takes a `return` statement and
+/// returns a boolean value indicating whether to abort the walk.
+///
+/// \returns `true` if the walk was aborted, `false` otherwise.
+static bool walkExplicitReturnStmts(const BraceStmt *BS,
+                                    function_ref<bool(ReturnStmt *)> callback) {
+  class Walker : public ASTWalker {
+    function_ref<bool(ReturnStmt *)> callback;
+
+  public:
+    Walker(decltype(Walker::callback) callback) : callback(callback) {}
+
+    MacroWalking getMacroWalkingBehavior() const override {
+      return MacroWalking::Arguments;
+    }
 
-public:
-  static std::vector<ReturnStmt *> find(const BraceStmt *BS) {
-    ReturnStmtFinder finder;
-    const_cast<BraceStmt *>(BS)->walk(finder);
-    return std::move(finder.ReturnStmts);
-  }
+    PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
+      return Action::SkipNode(E);
+    }
 
-  MacroWalking getMacroWalkingBehavior() const override {
-    return MacroWalking::Arguments;
-  }
+    PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
+      if (S->isImplicit()) {
+        return Action::SkipNode(S);
+      }
 
-  PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
-    return Action::SkipNode(E);
-  }
+      auto *returnStmt = dyn_cast<ReturnStmt>(S);
+      if (!returnStmt) {
+        return Action::Continue(S);
+      }
 
-  PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
-    // If we see a return statement, note it..
-    auto *returnStmt = dyn_cast<ReturnStmt>(S);
-    if (!returnStmt || returnStmt->isImplicit())
-      return Action::Continue(S);
+      if (callback(returnStmt)) {
+        return Action::Stop();
+      }
 
-    ReturnStmts.push_back(returnStmt);
-    return Action::SkipNode(S);
-  }
+      // Skip children & post walk and continue.
+      return Action::SkipNode(S);
+    }
 
-  /// Ignore patterns.
-  PreWalkResult<Pattern *> walkToPatternPre(Pattern *pat) override {
-    return Action::SkipNode(pat);
-  }
-};
-} // end anonymous namespace
+    /// Ignore patterns.
+    PreWalkResult<Pattern *> walkToPatternPre(Pattern *pat) override {
+      return Action::SkipNode(pat);
+    }
+  };
+
+  Walker walker(callback);
+
+  return const_cast<BraceStmt *>(BS)->walk(walker) == nullptr;
+}
 
 bool BraceHasExplicitReturnStmtRequest::evaluate(Evaluator &evaluator,
                                                  const BraceStmt *BS) const {
-  return !ReturnStmtFinder::find(BS).empty();
+  return walkExplicitReturnStmts(BS, [](ReturnStmt *) { return true; });
 }
 
 bool AnyFunctionRef::bodyHasExplicitReturnStmt() const {
@@ -1287,7 +1303,14 @@ std::vector<ReturnStmt *> TypeChecker::findReturnStatements(AnyFunctionRef fn) {
     return std::vector<ReturnStmt *>();
   }
 
-  return ReturnStmtFinder::find(fn.getBody());
+  std::vector<ReturnStmt *> results;
+
+  walkExplicitReturnStmts(fn.getBody(), [&results](ReturnStmt *RS) {
+    results.push_back(RS);
+    return false;
+  });
+
+  return results;
 }
 
 ResultBuilderOpSupport TypeChecker::checkBuilderOpSupport(