diff --git a/.jules/bolt.md b/.jules/bolt.md new file mode 100644 index 00000000..a00fa32a --- /dev/null +++ b/.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. diff --git a/src/wardline/scanner/ast_primitives.py b/src/wardline/scanner/ast_primitives.py index 70f565b3..bc68e4cb 100644 --- a/src/wardline/scanner/ast_primitives.py +++ b/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( diff --git a/src/wardline/scanner/rules/_ast_helpers.py b/src/wardline/scanner/rules/_ast_helpers.py index 7c3b52ff..7104fb61 100644 --- a/src/wardline/scanner/rules/_ast_helpers.py +++ b/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))