⚡️ Speed up function function_has_return_statement by 59%

Here is an optimized version of your function. The performance bottleneck, according to your line profiling, is the frequent and expensive use of `ast.iter_child_nodes(node)` and `stack.extend`, which results in a lot of small object allocations and function calls.

A standard approach for faster AST traversals is to avoid repeatedly building stack lists and avoid function call overhead in performance-critical loops. Additionally, instead of manually maintaining your own DFS stack, you can use a custom generator that flattens out iteration, but for **maximum speed**, we can use the following techniques.

- Use `__slots__` if building custom object wrappers (not needed here).
- **Replace `stack.extend` with direct in-place iteration** (avoid function call).
- Use a tuple for `append` instead of repeat calls if possible.
- Live with the stack, but **reduce attr lookups** by caching methods.
- Avoid `isinstance` in the hot path where possible (but that's hard here; checking for `ast.Return` is what we want).

But the biggest win is to avoid use of `ast.iter_child_nodes` within the loop. Since `ast.AST` objects all have a `_fields` attribute, you can directly and quickly access children yourself, avoiding the internal generator overhead.

#### Optimized code



### Key improvements

- **Avoid expensive ast.iter_child_nodes** in the loop. 
- **Reduce attribute lookups** by caching local variables (`pop`, `push`).
- **Directly scan node fields** to find children.

This version will usually run up to 2x faster on deep/crowded ASTs.  
The logic and return value are unchanged. All comments are preserved except for changes referring to iter_child_nodes, now referencing direct field inspection.

Author: codeflash-ai[bot]

codeflash/discovery/functions_to_optimize.py

@@ -604,11 +604,22 @@ def filter_files_optimized(file_path: Path, tests_root: Path, ignore_paths: list
 def function_has_return_statement(function_node: FunctionDef | AsyncFunctionDef) -> bool:
     # Custom DFS, return True as soon as a Return node is found
     stack = [function_node]
+    pop = stack.pop
+    push = stack.append
+    # Directly access _fields to avoid function call overhead of ast.iter_child_nodes
     while stack:
-        node = stack.pop()
+        node = pop()
         if isinstance(node, ast.Return):
             return True
-        stack.extend(ast.iter_child_nodes(node))
+        # Fast field inspection to avoid ast.iter_child_nodes overhead
+        for field in getattr(node, "_fields", ()):
+            value = getattr(node, field, None)
+            if isinstance(value, list):
+                for item in value:
+                    if isinstance(item, ast.AST):
+                        push(item)
+            elif isinstance(value, ast.AST):
+                push(value)
     return False