⚡️ Speed up method AsyncCallInstrumenter._call_in_positions by 33% in PR #769 (clean-async-branch)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #769

If you approve this dependent PR, these changes will be merged into the original PR branch clean-async-branch.

This PR will be automatically closed if the original PR is merged.

---

📄 33% (0.33x) speedup for AsyncCallInstrumenter._call_in_positions in codeflash/code_utils/instrument_existing_tests.py

⏱️ Runtime : 200 microseconds → 150 microseconds (best of 129 runs)

📝 Explanation and details

The optimization achieves a 33% speedup by eliminating redundant attribute lookups in the node_in_call_position function.

Key changes:

• Cached attribute access: Instead of repeatedly accessing node.lineno, node.col_offset, node.end_lineno, and node.end_col_offset within the loop, these values are now extracted once into local variables (node_lineno, node_col_offset, etc.) at the beginning of the function.
• Reduced getattr overhead: The optimization uses getattr() with default values for optional attributes (end_lineno, end_col_offset) instead of repeated hasattr() checks.
• Similar treatment for position attributes: pos.line_no and pos.col_no are cached as pos_line_no and pos_col_no to avoid repeated attribute lookups within the inner loop.

Why this improves performance:
In Python, attribute access has overhead due to the dynamic nature of object attribute resolution. When the same attributes are accessed multiple times in a loop (especially nested loops), this overhead compounds. By caching these values in local variables, the optimization reduces the number of attribute lookups from O(n) per attribute to O(1), where n is the number of positions being checked.

Test case performance patterns:

• Large-scale tests show the biggest gains (50-60% faster) because they iterate through many positions, maximizing the benefit of reduced attribute lookups
• Basic tests with few positions show moderate gains (5-17% faster) as the optimization overhead is minimal
• Edge cases with missing attributes show mixed results since the getattr() approach handles these cases differently but equivalently

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import ast
from typing import Optional

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Dummy stubs to allow tests to run (should match actual types)
class CodePosition:
    def __init__(
        self,
        line_no: Optional[int] = None,
        col_no: Optional[int] = None,
        end_col_offset: Optional[int] = None,
    ):
        self.line_no = line_no
        self.col_no = col_no
        self.end_col_offset = end_col_offset

class FunctionToOptimize:
    def __init__(self, function_name, parents=None, top_level_parent_name=None):
        self.function_name = function_name
        self.parents = parents or []
        self.top_level_parent_name = top_level_parent_name

class TestingMode:
    BEHAVIOR = "behavior"
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Helper to create ast.Call node with position attributes
def make_call_node(
    lineno: int,
    col_offset: int,
    end_lineno: Optional[int] = None,
    end_col_offset: Optional[int] = None,
) -> ast.Call:
    call_node = ast.Call()
    call_node.lineno = lineno
    call_node.col_offset = col_offset
    call_node.end_lineno = end_lineno if end_lineno is not None else lineno
    call_node.end_col_offset = end_col_offset if end_col_offset is not None else col_offset
    return call_node

# Basic Test Cases

def test_basic_exact_match():
    """Test: Call node matches exactly a CodePosition."""
    call_node = make_call_node(10, 5, 10, 15)
    positions = [CodePosition(line_no=10, col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.82μs -> 1.73μs (5.19% faster)

def test_basic_within_range():
    """Test: Call node covers a range, CodePosition is inside that range."""
    call_node = make_call_node(10, 0, 12, 20)
    positions = [CodePosition(line_no=11, col_no=10)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.87μs -> 1.62μs (15.4% faster)

def test_basic_end_line_and_col():
    """Test: Call node matches end line and end col."""
    call_node = make_call_node(10, 0, 12, 20)
    positions = [CodePosition(line_no=12, col_no=20, end_col_offset=20)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.86μs -> 1.58μs (17.7% faster)

def test_basic_not_in_position():
    """Test: Call node does not match any CodePosition."""
    call_node = make_call_node(5, 2, 8, 10)
    positions = [CodePosition(line_no=9, col_no=1)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.46μs -> 1.47μs (0.679% slower)

def test_basic_multiple_positions_one_matches():
    """Test: Multiple CodePositions, one matches."""
    call_node = make_call_node(10, 3, 10, 20)
    positions = [
        CodePosition(line_no=9, col_no=1),
        CodePosition(line_no=10, col_no=5),
        CodePosition(line_no=12, col_no=10),
    ]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.91μs -> 1.68μs (13.7% faster)

def test_basic_multiple_positions_none_match():
    """Test: Multiple CodePositions, none match."""
    call_node = make_call_node(1, 0, 1, 10)
    positions = [
        CodePosition(line_no=2, col_no=1),
        CodePosition(line_no=3, col_no=5),
    ]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.65μs -> 1.68μs (1.78% slower)

# Edge Test Cases

def test_edge_missing_lineno():
    """Test: Call node missing lineno attribute."""
    call_node = ast.Call()
    call_node.col_offset = 5
    call_node.end_lineno = 10
    call_node.end_col_offset = 15
    positions = [CodePosition(line_no=10, col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 510ns -> 521ns (2.11% slower)

def test_edge_missing_col_offset():
    """Test: Call node missing col_offset attribute."""
    call_node = ast.Call()
    call_node.lineno = 10
    call_node.end_lineno = 10
    call_node.end_col_offset = 15
    positions = [CodePosition(line_no=10, col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 611ns -> 542ns (12.7% faster)

def test_edge_missing_end_lineno():
    """Test: Call node missing end_lineno attribute."""
    call_node = ast.Call()
    call_node.lineno = 10
    call_node.col_offset = 5
    call_node.end_col_offset = 15
    positions = [CodePosition(line_no=10, col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    # node_in_call_position will use None for end_lineno, so no match
    codeflash_output = inst._call_in_positions(call_node) # 1.37μs -> 1.50μs (8.65% slower)

def test_edge_missing_end_col_offset():
    """Test: Call node missing end_col_offset attribute, but CodePosition expects it."""
    call_node = ast.Call()
    call_node.lineno = 10
    call_node.col_offset = 5
    call_node.end_lineno = 10
    positions = [CodePosition(line_no=10, col_no=5, end_col_offset=15)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    # Should not match because end_col_offset is missing on node
    codeflash_output = inst._call_in_positions(call_node) # 1.73μs -> 1.59μs (8.79% faster)

def test_edge_position_missing_line_no():
    """Test: CodePosition missing line_no."""
    call_node = make_call_node(10, 5, 10, 15)
    positions = [CodePosition(col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.20μs -> 1.43μs (16.1% slower)

def test_edge_position_missing_col_no():
    """Test: CodePosition missing col_no."""
    call_node = make_call_node(10, 5, 10, 15)
    positions = [CodePosition(line_no=10)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    # Should not match, col_no is required for match
    codeflash_output = inst._call_in_positions(call_node)

def test_edge_position_missing_end_col_offset():
    """Test: CodePosition missing end_col_offset, but node has it."""
    call_node = make_call_node(10, 5, 10, 15)
    positions = [CodePosition(line_no=10, col_no=15)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    # Should match, because end_col_offset is not required for match
    codeflash_output = inst._call_in_positions(call_node) # 2.04μs -> 2.12μs (3.77% slower)

def test_edge_position_line_no_outside_node():
    """Test: CodePosition line_no outside node's line range."""
    call_node = make_call_node(10, 5, 12, 15)
    positions = [CodePosition(line_no=13, col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.58μs -> 1.71μs (7.59% slower)

def test_edge_position_line_no_before_node():
    """Test: CodePosition line_no before node's line range."""
    call_node = make_call_node(10, 5, 12, 15)
    positions = [CodePosition(line_no=9, col_no=5)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.46μs -> 1.58μs (7.64% slower)

def test_edge_position_line_no_equals_end_lineno():
    """Test: CodePosition line_no equals node's end_lineno, col_no < end_col_offset."""
    call_node = make_call_node(10, 5, 12, 15)
    positions = [CodePosition(line_no=12, col_no=10, end_col_offset=15)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.95μs -> 1.69μs (15.4% faster)

def test_edge_position_line_no_equals_start_and_col_no_before_col_offset():
    """Test: CodePosition line_no equals node's lineno, col_no before col_offset."""
    call_node = make_call_node(10, 5, 12, 15)
    positions = [CodePosition(line_no=10, col_no=4)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 1.95μs -> 1.70μs (14.7% faster)

# Large Scale Test Cases

def test_large_scale_many_positions_one_matches():
    """Test: Large number of positions, one matches."""
    call_node = make_call_node(100, 50, 100, 100)
    positions = [CodePosition(line_no=i, col_no=50) for i in range(1, 1000)]
    positions.append(CodePosition(line_no=100, col_no=50))
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 14.6μs -> 9.11μs (60.2% faster)

def test_large_scale_many_positions_none_match():
    """Test: Large number of positions, none match."""
    call_node = make_call_node(100, 50, 100, 100)
    positions = [CodePosition(line_no=i, col_no=50) for i in range(1, 100)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    codeflash_output = inst._call_in_positions(call_node) # 9.40μs -> 6.88μs (36.5% faster)

def test_large_scale_many_nodes_one_matches():
    """Test: Large number of call nodes, one matches."""
    positions = [CodePosition(line_no=500, col_no=50)]
    nodes = [make_call_node(i, 50, i, 100) for i in range(1, 1000)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    found = False
    for node in nodes:
        if inst._call_in_positions(node):
            found = True
            break

def test_large_scale_many_nodes_none_match():
    """Test: Large number of call nodes, none match."""
    positions = [CodePosition(line_no=1001, col_no=50)]
    nodes = [make_call_node(i, 50, i, 100) for i in range(1, 1000)]
    inst = AsyncCallInstrumenter(FunctionToOptimize("f"), "", "", positions)
    found = False
    for node in nodes:
        if inst._call_in_positions(node):
            found = True
            break


#------------------------------------------------
import ast
from typing import Optional

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Mocks for codeflash models (minimal implementations for testability)
class CodePosition:
    def __init__(self, line_no: Optional[int], col_no: Optional[int], end_col_offset: Optional[int] = None):
        self.line_no = line_no
        self.col_no = col_no
        self.end_col_offset = end_col_offset

class FunctionToOptimize:
    def __init__(self, function_name: str, parents=None, top_level_parent_name=None):
        self.function_name = function_name
        self.parents = parents or []
        self.top_level_parent_name = top_level_parent_name

class TestingMode:
    BEHAVIOR = "BEHAVIOR"
from codeflash.code_utils.instrument_existing_tests import \
    AsyncCallInstrumenter


# Helper function to create a fake ast.Call node with line/col info
def make_call_node(lineno, col_offset, end_lineno=None, end_col_offset=None):
    node = ast.Call()
    node.lineno = lineno
    node.col_offset = col_offset
    node.end_lineno = end_lineno if end_lineno is not None else lineno
    node.end_col_offset = end_col_offset if end_col_offset is not None else col_offset
    return node

# =========================
# Unit Tests for _call_in_positions
# =========================

# Basic Test Cases

def test_basic_single_position_exact_start():
    """Test: Position matches exactly at call start."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=5)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 2.06μs -> 1.82μs (13.2% faster)

def test_basic_single_position_inside_call():
    """Test: Position is inside the call (not exactly at start/end)."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=7)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.69μs -> 1.78μs (5.05% slower)

def test_basic_single_position_at_end():
    """Test: Position matches exactly at call end."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=10, end_col_offset=10)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.61μs -> 1.64μs (1.77% slower)

def test_basic_single_position_outside_call():
    """Test: Position is outside the call span."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=4, col_no=1)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.43μs -> 1.58μs (9.48% slower)

def test_basic_multiple_positions_one_matches():
    """Test: Multiple positions, one matches."""
    f = FunctionToOptimize("foo")
    call_positions = [
        CodePosition(line_no=2, col_no=1),
        CodePosition(line_no=3, col_no=7),
        CodePosition(line_no=5, col_no=3),
    ]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.85μs -> 1.84μs (0.488% faster)

def test_basic_multiple_positions_none_match():
    """Test: Multiple positions, none match."""
    f = FunctionToOptimize("foo")
    call_positions = [
        CodePosition(line_no=2, col_no=1),
        CodePosition(line_no=4, col_no=7),
        CodePosition(line_no=5, col_no=3),
    ]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.79μs -> 1.86μs (3.81% slower)

# Edge Test Cases

def test_edge_no_lineno_or_col_offset():
    """Test: Node missing lineno/col_offset attributes."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=5)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = ast.Call()  # No lineno/col_offset
    codeflash_output = instr._call_in_positions(call_node) # 480ns -> 441ns (8.84% faster)

def test_edge_position_line_none():
    """Test: Position with None line_no (should not match)."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=None, col_no=5)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.21μs -> 1.49μs (18.8% slower)

def test_edge_call_node_end_lineno_none():
    """Test: Node with end_lineno=None (should not match)."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=5)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, None, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.61μs -> 1.62μs (0.616% slower)

def test_edge_position_at_multiline_call_middle():
    """Test: Position inside a multi-line call."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=4, col_no=2)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 5, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.76μs -> 1.66μs (6.01% faster)

def test_edge_position_at_multiline_call_start():
    """Test: Position at start of multi-line call."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=5)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 5, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.57μs -> 1.53μs (2.61% faster)

def test_edge_position_at_multiline_call_end():
    """Test: Position at end of multi-line call."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=5, col_no=10, end_col_offset=10)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 5, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.81μs -> 1.62μs (11.7% faster)

def test_edge_position_at_multiline_call_outside():
    """Test: Position outside multi-line call."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=6, col_no=1)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 5, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.43μs -> 1.53μs (6.52% slower)

def test_edge_position_col_offset_before_call():
    """Test: Position at correct line but before call col_offset."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=2)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.86μs -> 1.66μs (12.1% faster)

def test_edge_position_end_col_offset_none():
    """Test: Position at end line but end_col_offset is None (should not match)."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=10, end_col_offset=None)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.55μs -> 1.56μs (0.640% slower)

def test_edge_position_call_node_end_col_offset_none():
    """Test: Node end_col_offset is None (should fallback to col_offset)."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=3, col_no=10, end_col_offset=10)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(3, 5, 3, None)
    codeflash_output = instr._call_in_positions(call_node) # 1.55μs -> 1.49μs (4.02% faster)

# Large Scale Test Cases

def test_large_many_positions_some_match():
    """Test: Large number of positions, some match."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=i, col_no=5) for i in range(1, 1001)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(500, 5, 500, 10)
    codeflash_output = instr._call_in_positions(call_node) # 41.2μs -> 27.4μs (50.4% faster)

def test_large_many_positions_none_match():
    """Test: Large number of positions, none match."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=i, col_no=5) for i in range(1, 1001)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(1002, 5, 1002, 10)
    codeflash_output = instr._call_in_positions(call_node) # 79.1μs -> 52.3μs (51.2% faster)

def test_large_call_spanning_many_lines():
    """Test: Call node spanning many lines, position in the middle."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=500, col_no=5)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(1, 1, 1000, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.79μs -> 1.67μs (7.23% faster)

def test_large_positions_all_match():
    """Test: All positions match (all inside call span)."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=i, col_no=5) for i in range(10, 21)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(10, 5, 20, 10)
    codeflash_output = instr._call_in_positions(call_node) # 1.56μs -> 1.52μs (2.63% faster)

def test_large_positions_all_outside():
    """Test: All positions outside call span."""
    f = FunctionToOptimize("foo")
    call_positions = [CodePosition(line_no=i, col_no=5) for i in range(21, 31)]
    instr = AsyncCallInstrumenter(f, "mod.py", "pytest", call_positions)
    call_node = make_call_node(10, 5, 20, 10)
    codeflash_output = instr._call_in_positions(call_node) # 2.38μs -> 2.08μs (14.4% 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-pr769-2025-09-27T01.12.48 and push.