⚡️ Speed up function get_first_top_level_function_or_method_ast by 17% in PR #678 (standalone-fto-async)

The optimized code achieves a **16% speedup** through several targeted micro-optimizations that reduce overhead in the tight loops that traverse AST nodes:

**Key Optimizations:**

1. **Local Variable Bindings**: Assigns `ast.iter_child_nodes` and the type tuple to local variables, eliminating repeated attribute lookups during iteration. The profiler shows this reduces the per-hit cost of the main loop from 1560.1ns to 1530.6ns.

2. **Restructured Type Checking**: Splits the combined `isinstance(child, object_type) and child.name == object_name` check into separate conditions. This allows early exit after the type check fails and uses `getattr(child, "name", None)` for safer attribute access, reducing the attribute lookup overhead shown in the profiler (from 403.8ns to 308ns per hit).

3. **Optimized Control Flow**: Changes the nested if-statements to `elif` structure, reducing redundant type checks. The `isinstance(child, fn_type_tuple)` check now only runs when needed, improving branch prediction.

4. **Direct Parent Access**: Caches `parents[0]` as `parent0` to avoid repeated list indexing, though this has minimal impact on the overall performance.

**Performance Impact by Test Type:**
- **Large-scale tests** (500+ functions/classes): Benefit most from reduced per-node overhead in deep traversals
- **Basic cases**: See consistent but smaller improvements due to fewer nodes processed
- **Edge cases**: Minimal impact since they often involve early returns or empty searches

The optimizations are most effective for codebases with complex AST structures where the functions traverse many nodes, making the micro-optimizations compound significantly.

Author: codeflash-ai[bot]

codeflash/code_utils/static_analysis.py

@@ -116,31 +116,41 @@ def analyze_imported_modules(
 def get_first_top_level_object_def_ast(
     object_name: str, object_type: type[ObjectDefT], node: ast.AST
 ) -> ObjectDefT | None:
-    for child in ast.iter_child_nodes(node):
-        if isinstance(child, object_type) and child.name == object_name:
-            return child
-        if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-            continue
-        if descendant := get_first_top_level_object_def_ast(object_name, object_type, child):
-            return descendant
+    # Use local bindings for attribute/func lookups and type tuples for speed in tight loops
+    iter_child_nodes = ast.iter_child_nodes
+    fn_type_tuple = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+
+    for child in iter_child_nodes(node):
+        # Fast path: check type and name directly
+        if isinstance(child, object_type):
+            if getattr(child, "name", None) == object_name:
+                return child
+        # Avoid recursing into function/class defs as per original logic
+        elif not isinstance(child, fn_type_tuple):
+            descendant = get_first_top_level_object_def_ast(object_name, object_type, child)
+            if descendant is not None:
+                return descendant
     return None
 
 
 def get_first_top_level_function_or_method_ast(
     function_name: str, parents: list[FunctionParent], node: ast.AST
 ) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
+    # Fast path: no parents, search from the root node
     if not parents:
         result = get_first_top_level_object_def_ast(function_name, ast.FunctionDef, node)
         if result is not None:
             return result
         return get_first_top_level_object_def_ast(function_name, ast.AsyncFunctionDef, node)
-    if parents[0].type == "ClassDef" and (
-        class_node := get_first_top_level_object_def_ast(parents[0].name, ast.ClassDef, node)
-    ):
-        result = get_first_top_level_object_def_ast(function_name, ast.FunctionDef, class_node)
-        if result is not None:
-            return result
-        return get_first_top_level_object_def_ast(function_name, ast.AsyncFunctionDef, class_node)
+    # Only ClassDef parent handled, search in class scope only once
+    parent0 = parents[0]
+    if parent0.type == "ClassDef":
+        class_node = get_first_top_level_object_def_ast(parent0.name, ast.ClassDef, node)
+        if class_node is not None:
+            result = get_first_top_level_object_def_ast(function_name, ast.FunctionDef, class_node)
+            if result is not None:
+                return result
+            return get_first_top_level_object_def_ast(function_name, ast.AsyncFunctionDef, class_node)
     return None