⚡ Bolt: [performance improvement]#47
Conversation
💡 What: Replaced recursive `yield from` calls with eager, stack-based iteration using list-appending for hot-path AST traversal functions. Maintained `isinstance()` type checks for type safety and code readability. 🎯 Why: Using `yield from` recursion introduces the overhead of creating and advancing generator frames and function calls. Eager list population combined with stack-based iteration avoids these overheads and handles deep trees without hitting recursion limits, offering a measureable performance improvement for AST walking. 📊 Impact: Faster static analysis times due to reduced function call overhead and generator instantiation during code parsing. 🔬 Measurement: Verified with `make test` checking for regressions on standard workloads and making sure the changes pass all assertions. Tested order of traversal is strictly preserved. Co-authored-by: tachyon-beep <544926+tachyon-beep@users.noreply.github.com>
|
👋 Jules, reporting for duty! I'm here to lend a hand with this pull request. When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down. I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job! For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with New to Jules? Learn more at jules.google/docs. For security, I will only act on instructions from the user who triggered this task. |
1 participant
⚡ Bolt: [performance improvement]
💡 What: Replaced recursive
yield fromcalls with eager, stack-based iteration using list-appending for hot-path AST traversal functions (iter_calls_in_function_body,_own_statements,_walk_own_non_stmt_children,_walk_own,_own_calls,_own_nodes_in,_target_names,_own_scope_lambdas,walkin analyzer, etc). Maintainedisinstance()type checks to ensure type safety.🎯 Why:
yield fromrecursion introduces generator frame overhead and function call overhead which becomes expensive during heavy AST traversal. Eager list population using a stack is much more performant and also avoids deep recursion limits.📊 Impact: Speeds up hot-path AST traversal operations, making the static analysis tool faster overall.
🔬 Measurement: Run
make testto ensure tests passed and AST traversal logic works as before (e.g. keeping standard traversal order for children, decorators, defaults).PR created automatically by Jules for task 11364911538698350545 started by @tachyon-beep