⚡️ Speed up method FunctionCallFinder._get_call_name by 113%

[codeflash-ai]

📄 113% (1.13x) speedup for FunctionCallFinder._get_call_name in codeflash/code_utils/code_extractor.py

⏱️ Runtime : 832 microseconds → 391 microseconds (best of 40 runs)

📝 Explanation and details

The optimized version improves performance by replacing the while isinstance() condition with a tighter while True loop that explicitly checks types inside the loop body. This eliminates redundant isinstance() calls on each iteration.

Key optimizations:

1. Eliminated redundant type checking: The original code calls isinstance(current, ast.Attribute) twice per iteration - once in the while condition and again when accessing current.value. The optimized version uses a single isinstance() check per iteration.

2. More efficient loop structure: Changed from while isinstance(current, ast.Attribute): to while True: with explicit type checks and early exits using continue and break. This reduces function call overhead on each loop iteration.

3. Direct variable assignment: Uses val = current.value once and reuses it, avoiding repeated property access.

Performance impact by test case type:

• Simple names (foo()): ~133% faster due to reduced overhead in the fast path
• Attribute chains (obj.bar(), pkg.mod.func()): ~114-225% faster, with deeper chains seeing more benefit
• Long chains (100+ attributes): ~70% faster, where the loop optimization compounds significantly
• Edge cases (non-callable nodes): ~92-191% faster due to faster bailout paths

The optimization is particularly effective for attribute chain resolution, which is common in method calls and module imports - the primary use case for this AST analysis code.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 2438 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import ast

# imports
import pytest
from codeflash.code_utils.code_extractor import FunctionCallFinder


# function to test
def _get_call_name(func_node):
    """Extract the name being called from a function node."""
    # Fast path short-circuit for ast.Name nodes
    if isinstance(func_node, ast.Name):
        return func_node.id
    # Build attribute chain with a single walk and no string op in loop
    if isinstance(func_node, ast.Attribute):
        # Use list-prepend and join for reversed chain (faster than += string)
        parts = []
        current = func_node
        while isinstance(current, ast.Attribute):
            parts.append(current.attr)
            current = current.value
        if isinstance(current, ast.Name):
            parts.append(current.id)
            # Avoid extra function call by reversing while joining
            return ".".join(parts[::-1])  # slightly faster than reversed()
    return None

# Helper function to parse code and extract the function node from a Call
def get_func_node_from_call(code: str):
    """
    Parse a Python expression containing a function call and return the func node of the Call.
    """
    expr = ast.parse(code, mode="eval")
    return expr.body.func

# -------------------------
# Basic Test Cases
# -------------------------


































#------------------------------------------------
import ast

# imports
import pytest
from codeflash.code_utils.code_extractor import FunctionCallFinder

# unit tests

# Helper function to parse a function call expression and return the func node
def get_func_node(expr: str):
    """
    Parse a Python expression string and return the func node for a Call.
    """
    tree = ast.parse(expr)
    # Find the ast.Call node
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            return node.func
    raise ValueError("No ast.Call node found in expression")

# Basic Test Cases

def test_get_call_name_simple_name():
    # Test basic function call: foo()
    func_node = get_func_node("foo()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.17μs -> 500ns (133% faster)

def test_get_call_name_simple_attribute():
    # Test attribute call: obj.bar()
    func_node = get_func_node("obj.bar()")
    finder = FunctionCallFinder("bar", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 5.42μs -> 1.67μs (225% faster)

def test_get_call_name_nested_attribute():
    # Test nested attribute: pkg.mod.func()
    func_node = get_func_node("pkg.mod.func()")
    finder = FunctionCallFinder("func", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 4.38μs -> 1.67μs (163% faster)

def test_get_call_name_deep_attribute_chain():
    # Test deep attribute chain: a.b.c.d.e()
    func_node = get_func_node("a.b.c.d.e()")
    finder = FunctionCallFinder("e", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 3.92μs -> 1.83μs (114% faster)

def test_get_call_name_builtin_function():
    # Test builtin function call: len(x)
    func_node = get_func_node("len(x)")
    finder = FunctionCallFinder("len", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 875ns -> 375ns (133% faster)

# Edge Test Cases

def test_get_call_name_none_for_literal():
    # Test call on a literal (should not occur, but should return None)
    # e.g. (42)() is invalid, but let's try ast.Num as func_node
    node = ast.Constant(value=42)
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(node); result = codeflash_output # 1.04μs -> 542ns (92.1% faster)

def test_get_call_name_none_for_lambda():
    # Test call on a lambda (should return None)
    expr = "(lambda x: x)(42)"
    tree = ast.parse(expr)
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            func_node = node.func
            break
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.17μs -> 458ns (155% faster)

def test_get_call_name_none_for_call_node():
    # Test passing a Call node itself (not its func)
    expr = "foo()"
    tree = ast.parse(expr)
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            call_node = node
            break
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(call_node); result = codeflash_output # 1.50μs -> 583ns (157% faster)

def test_get_call_name_none_for_subscript():
    # Test subscript as function: arr[0]()
    func_node = get_func_node("arr[0]()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.33μs -> 458ns (191% faster)

def test_get_call_name_none_for_tuple():
    # Test tuple as function: (a, b)()
    func_node = get_func_node("(a, b)()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.04μs -> 416ns (150% faster)

def test_get_call_name_none_for_list():
    # Test list as function: [a, b]()
    func_node = get_func_node("[a, b]()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.25μs -> 458ns (173% faster)

def test_get_call_name_none_for_dict():
    # Test dict as function: {'a': 1}()
    func_node = get_func_node("{'a': 1}()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.17μs -> 458ns (155% faster)

def test_get_call_name_none_for_set():
    # Test set as function: {1, 2}()
    func_node = get_func_node("{1, 2}()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.12μs -> 417ns (170% faster)

def test_get_call_name_none_for_comprehension():
    # Test comprehension as function: [x for x in range(5)]()
    func_node = get_func_node("[x for x in range(5)]()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 1.33μs -> 458ns (191% faster)

def test_get_call_name_none_for_constant():
    # Test constant as function: None()
    func_node = get_func_node("None()")
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 917ns -> 417ns (120% faster)

def test_get_call_name_none_for_unusual_ast_type():
    # Test passing an ast.Module node (should return None)
    node = ast.Module(body=[])
    finder = FunctionCallFinder("foo", "", [])
    codeflash_output = finder._get_call_name(node); result = codeflash_output # 958ns -> 417ns (130% faster)

def test_get_call_name_attribute_with_number():
    # Test attribute chain with number: obj1.obj2.obj3_2.func()
    func_node = get_func_node("obj1.obj2.obj3_2.func()")
    finder = FunctionCallFinder("func", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 3.79μs -> 1.71μs (122% faster)

def test_get_call_name_attribute_with_underscore():
    # Test attribute chain with underscores: a_b.c_d.e_f()
    func_node = get_func_node("a_b.c_d.e_f()")
    finder = FunctionCallFinder("e_f", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 3.00μs -> 1.42μs (112% faster)


def test_get_call_name_attribute_with_unicode():
    # Test attribute chain with unicode: α.β.γ()
    func_node = get_func_node("α.β.γ()")
    finder = FunctionCallFinder("γ", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 5.62μs -> 1.83μs (207% faster)

# Large Scale Test Cases

def test_get_call_name_long_attribute_chain():
    # Test long attribute chain (100 attributes): a.b.c.d....z.func()
    chain = ".".join([f"attr{i}" for i in range(1, 100)]) + ".func()"
    func_node = get_func_node(chain)
    finder = FunctionCallFinder("func", "", [])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 20.6μs -> 12.1μs (70.7% faster)
    expected = ".".join([f"attr{i}" for i in range(1, 100)] + ["func"])

def test_get_call_name_many_calls():
    # Test many calls in a row, ensure each is correct
    for i in range(1, 100):
        expr = f"obj{i}.func{i}()"
        func_node = get_func_node(expr)
        finder = FunctionCallFinder(f"func{i}", "", [])
        codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 123μs -> 51.6μs (140% faster)

def test_get_call_name_large_number_of_simple_names():
    # Test many simple names (simulate scalability)
    for i in range(1, 1000):
        expr = f"func_{i}()"
        func_node = get_func_node(expr)
        finder = FunctionCallFinder(f"func_{i}", "", [])
        codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 342μs -> 163μs (110% faster)

def test_get_call_name_large_number_of_deep_chains():
    # Test 100 deep chains of length 10
    for i in range(1, 101):
        chain = ".".join([f"obj{i}_{j}" for j in range(10)]) + ".func()"
        func_node = get_func_node(chain)
        finder = FunctionCallFinder("func", "", [])
        expected = ".".join([f"obj{i}_{j}" for j in range(10)] + ["func"])
        codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 296μs -> 144μs (106% faster)

def test_get_call_name_large_attribute_chain_with_unicode():
    # Test attribute chain with unicode and length 20
    chain = ".".join([f"α{i}" for i in range(20)]) + ".ω()"
    func_node = get_func_node(chain)
    finder = FunctionCallFinder("ω", "", [])
    expected = ".".join([f"α{i}" for i in range(20)] + ["ω"])
    codeflash_output = finder._get_call_name(func_node); result = codeflash_output # 6.92μs -> 3.21μs (116% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-FunctionCallFinder._get_call_name-mgzrorsj and push.