[SILOptimizer] Clean up infinite recursion diagnostic pass (#19710)

* [SILOptimizer] Clean up infinite recursion diagnostic pass

NFC. This cleans up the pass to avoid the extra lambda and to clear up
the ordering of what check is supposed to come before what.

* Address review comments

Author: Harlan

lib/SILOptimizer/Mandatory/DiagnoseInfiniteRecursion.cpp

@@ -94,37 +94,39 @@ static bool hasRecursiveCallInPath(SILBasicBlock &Block,
   return false;
 }
 
-static bool hasInfinitelyRecursiveApply(SILFunction &Fn,
-                                        SILFunction *TargetFn) {
-  SmallPtrSet<SILBasicBlock *, 16> Visited;
-  SmallVector<SILBasicBlock *, 16> WorkList;
-  // Keep track of whether we found at least one recursive path.
+/// Perform a DFS through the target function to find any paths to an exit node
+/// that do not call into the target.
+static bool hasInfinitelyRecursiveApply(SILFunction *targetFn) {
+  SmallPtrSet<SILBasicBlock *, 32> visited = { targetFn->getEntryBlock() };
+  SmallVector<SILBasicBlock *, 32> workList = { targetFn->getEntryBlock() };
+
+  // Keep track of if we've found any recursive blocks at all.
+  // We return true if we found any recursion and did not find any
+  // non-recursive, function-exiting blocks.
   bool foundRecursion = false;
+  auto *targetModule = targetFn->getModule().getSwiftModule();
 
-  auto *TargetModule = TargetFn->getModule().getSwiftModule();
-  auto analyzeSuccessor = [&](SILBasicBlock *Succ) -> bool {
-    if (!Visited.insert(Succ).second)
-      return false;
+  while (!workList.empty()) {
+    SILBasicBlock *curBlock = workList.pop_back_val();
 
-    // If the successor block contains a recursive call, end analysis there.
-    if (!hasRecursiveCallInPath(*Succ, TargetFn, TargetModule)) {
-      WorkList.push_back(Succ);
-      return false;
+    // We're looking for functions that are recursive on _all_ paths. If this
+    // block is recursive, mark that we found recursion and check the next
+    // block in the work list.
+    if (hasRecursiveCallInPath(*curBlock, targetFn, targetModule)) {
+      foundRecursion = true;
+      continue;
     }
-    return true;
-  };
 
-  // Seed the work list with the entry block.
-  foundRecursion |= analyzeSuccessor(Fn.getEntryBlock());
-  
-  while (!WorkList.empty()) {
-    SILBasicBlock *CurBlock = WorkList.pop_back_val();
-    // Found a path to the exit node without a recursive call.
-    if (CurBlock->getTerminator()->isFunctionExiting())
+    // If this block doesn't have a recursive call, and it exits the function,
+    // then we know the function is not infinitely recursive.
+    if (curBlock->getTerminator()->isFunctionExiting())
       return false;
 
-    for (SILBasicBlock *Succ : CurBlock->getSuccessorBlocks())
-      foundRecursion |= analyzeSuccessor(Succ);
+    // Otherwise, push the successors onto the stack if we haven't visited them.
+    for (auto *succ : curBlock->getSuccessorBlocks()) {
+      if (visited.insert(succ).second)
+        workList.push_back(succ);
+    }
   }
   return foundRecursion;
 }
@@ -149,7 +151,7 @@ namespace {
       if (!Fn->hasLocation() || Fn->getLocation().getSourceLoc().isInvalid())
         return;
 
-      if (hasInfinitelyRecursiveApply(*Fn, Fn)) {
+      if (hasInfinitelyRecursiveApply(Fn)) {
         diagnose(Fn->getModule().getASTContext(),
                  Fn->getLocation().getSourceLoc(),
                  diag::warn_infinite_recursive_function);