⚡ Bolt: [performance improvement] Replace recursive generator AST traversal with explicit stack

.jules/bolt.md

@@ -0,0 +1,3 @@
+## 2026-06-11 - AST Traversal Recursion Overhead
+**Learning:** `yield from` recursion over AST nodes (`ast.iter_child_nodes`) adds significant generator delegation overhead on deep trees in this codebase, increasing runtime significantly.
+**Action:** Use an explicit stack populated via `node._fields` (pushed in reverse order) combined with `yield` instead of `yield from`. This maintains the exact execution order and lazy evaluation while removing the deep call stack and generator proxy overhead.

src/wardline/scanner/ast_primitives.py

@@ -104,39 +104,64 @@ def iter_calls_in_function_body(
     Header expressions that execute in the enclosing scope (decorators, default
     values, base classes, metaclass keywords) are still attributed to ``node``.
     """
+    stack: list[ast.AST] = list(reversed(node.body))
+
+    while stack:
+        current = stack.pop()
 
-    def walk_node(current: ast.AST) -> Iterator[ast.Call]:
         if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            children: list[ast.AST] = []
             for decorator in current.decorator_list:
-                yield from walk_node(decorator)
-            yield from _walk_argument_defaults(current.args)
-            return
+                children.append(decorator)
+            for default in current.args.defaults:
+                children.append(default)
+            for kw_default in current.args.kw_defaults:
+                if kw_default is not None:
+                    children.append(kw_default)
+            if children:
+                stack.extend(reversed(children))
+            continue
+
         if isinstance(current, ast.ClassDef):
+            children = []
             for decorator in current.decorator_list:
-                yield from walk_node(decorator)
+                children.append(decorator)
             for base in current.bases:
-                yield from walk_node(base)
+                children.append(base)
             for keyword in current.keywords:
-                yield from walk_node(keyword.value)
-            return
+                children.append(keyword.value)
+            if children:
+                stack.extend(reversed(children))
+            continue
+
         if isinstance(current, ast.Lambda):
-            yield from _walk_argument_defaults(current.args)
-            return
+            children = []
+            for default in current.args.defaults:
+                children.append(default)
+            for kw_default in current.args.kw_defaults:
+                if kw_default is not None:
+                    children.append(kw_default)
+            if children:
+                stack.extend(reversed(children))
+            continue
+
         if isinstance(current, ast.Call):
             yield current
-        for child in ast.iter_child_nodes(current):
-            yield from walk_node(child)
-
-    def _walk_argument_defaults(args: ast.arguments) -> Iterator[ast.Call]:
-        for default in args.defaults:
-            yield from walk_node(default)
-        for kw_default in args.kw_defaults:
-            if kw_default is None:
-                continue
-            yield from walk_node(kw_default)
 
-    for stmt in node.body:
-        yield from walk_node(stmt)
+        children = []
+        for name in current._fields:
+            try:
+                field = getattr(current, name)
+            except AttributeError:
+                continue
+            if isinstance(field, ast.AST):
+                children.append(field)
+            elif isinstance(field, list):
+                for item in field:
+                    if isinstance(item, ast.AST):
+                        children.append(item)
+        if children:
+            stack.extend(reversed(children))
 
 
 def resolve_self_method_fqn(

src/wardline/scanner/rules/_ast_helpers.py

@@ -67,14 +67,46 @@ def _own_nodes_in_reachable_stmt(stmt: ast.stmt) -> Iterator[ast.AST]:
 
 
 def _walk_own_non_stmt_children(node: ast.AST) -> Iterator[ast.AST]:
-    for child in ast.iter_child_nodes(node):
-        if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
-            yield child
-        elif isinstance(child, ast.stmt):
+    stack: list[ast.AST] = []
+
+    children: list[ast.AST] = []
+    for name in node._fields:
+        try:
+            field = getattr(node, name)
+        except AttributeError:
+            continue
+        if isinstance(field, ast.AST):
+            children.append(field)
+        elif isinstance(field, list):
+            for item in field:
+                if isinstance(item, ast.AST):
+                    children.append(item)
+    if children:
+        stack.extend(reversed(children))
+
+    while stack:
+        current = stack.pop()
+
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            yield current
+        elif isinstance(current, ast.stmt):
             continue
         else:
-            yield child
-            yield from _walk_own_non_stmt_children(child)
+            yield current
+            curr_children = []
+            for name in current._fields:
+                try:
+                    field = getattr(current, name)
+                except AttributeError:
+                    continue
+                if isinstance(field, ast.AST):
+                    curr_children.append(field)
+                elif isinstance(field, list):
+                    for item in field:
+                        if isinstance(item, ast.AST):
+                            curr_children.append(item)
+            if curr_children:
+                stack.extend(reversed(curr_children))
 
 
 def _reachable_statements_in_block(
@@ -639,9 +671,41 @@ def own_nodes(node: ast.AST) -> Iterator[ast.AST]:
 
 
 def _walk_own(node: ast.AST) -> Iterator[ast.AST]:
-    for child in ast.iter_child_nodes(node):
-        if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
-            yield child
+    stack: list[ast.AST] = []
+
+    children: list[ast.AST] = []
+    for name in node._fields:
+        try:
+            field = getattr(node, name)
+        except AttributeError:
+            continue
+        if isinstance(field, ast.AST):
+            children.append(field)
+        elif isinstance(field, list):
+            for item in field:
+                if isinstance(item, ast.AST):
+                    children.append(item)
+    if children:
+        stack.extend(reversed(children))
+
+    while stack:
+        current = stack.pop()
+
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
+            yield current
         else:
-            yield child
-            yield from _walk_own(child)
+            yield current
+            curr_children = []
+            for name in current._fields:
+                try:
+                    field = getattr(current, name)
+                except AttributeError:
+                    continue
+                if isinstance(field, ast.AST):
+                    curr_children.append(field)
+                elif isinstance(field, list):
+                    for item in field:
+                        if isinstance(item, ast.AST):
+                            curr_children.append(item)
+            if curr_children:
+                stack.extend(reversed(curr_children))