⚡️ Speed up function convert_parents_to_tuple by 2,092% in PR #1561 (add/support_react)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1561

If you approve this dependent PR, these changes will be merged into the original PR branch add/support_react.

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

---

📄 2,092% (20.92x) speedup for convert_parents_to_tuple in codeflash/languages/base.py

⏱️ Runtime : 116 milliseconds → 5.29 milliseconds (best of 229 runs)

📝 Explanation and details

Brief: The optimized function cuts the original 116 ms wall time down to 5.29 ms (≈2092% relative speedup) by adding a fast-path that detects when the input already contains FunctionParent instances and avoids rebuilding them. This reduces the dominant cost (many pydantic/dataclass constructions and memory allocations) and is why runtime falls by orders of magnitude.

What changed (concrete):

• Fast-path checks:
  • If input is a tuple and every element is already a FunctionParent, return it directly.
  • If input is a list and every element is already a FunctionParent, convert to tuple(parents) (no per-element reconstruction).
  • Early empty-sequence checks return tuple() immediately.
• Fallback: only if elements are not FunctionParent, construct new FunctionParent instances as before.

Why this is faster (technical reasons):

• Dataclass/pydantic construction is relatively expensive. The original always called FunctionParent(...) for every element; that meant constructor validation and allocation for each item even when elements were already the correct type. Avoiding those calls eliminates that work.
• Fewer memory allocations: returning the existing tuple (or making a shallow tuple from an existing list) avoids allocating N new FunctionParent objects and reduces GC pressure.
• Reduced Python-level overhead: generator-driven per-item construction and attribute reads are removed in the common case.
• The line profiler confirms the shift: original time is concentrated in the single construction line; optimized profiling shows most work moved to inexpensive isinstance/all checks and a much smaller remainder for construction only when needed.

Observed trade-offs / behavior notes:

• Error cases that hit the fallback (inputs that lack .name/.type) do a bit more work (extra isinstance checks) before failing; annotated tests show those cases became slightly slower (~25–30% slower). This is a reasonable trade-off because the common/correct case is dramatically faster.
• The function now may return the input tuple object unchanged (instead of always returning a freshly-built tuple of new FunctionParent instances). Because FunctionParent is a frozen dataclass here, returning the same instances is safe in practice; however, callers that relied on identity-new objects (is-comparisons or expecting brand-new instances) should be aware of this subtle change.

Where this helps most (based on tests and profiles):

• Large inputs: converting lists of 1000 FunctionParent instances fell from ~1.15 ms to ~46 μs (huge win).
• Repeated conversions in hot paths: a loop of 1000 conversions on a medium-sized list went from ~110 ms to ~4.63 ms — this function is now far cheaper in tight loops.
• Small common cases (non-empty lists/tuples of FunctionParent) are severalx faster (see many annotated tests with >2x up to 20x speedups).

Summary:
The optimization targets the dominant cost — reconstructing validated dataclass instances — by detecting when that work is unnecessary and short-circuiting it. That yields the large runtime improvement while preserving correctness for the common use cases; the only notable trade-off is slightly slower failure paths and the semantic change of preserving existing instances rather than producing brand-new ones (which is safe here because FunctionParent is frozen).

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from codeflash.languages.base import convert_parents_to_tuple
from codeflash.models.function_types import \
    FunctionParent  # concrete dataclass used by the function

def test_basic_conversion_from_list_creates_equivalent_functionparents():
    # Create a simple list of FunctionParent instances (real instances, not mocks)
    src = [FunctionParent(name="parent1", type="module"), FunctionParent(name="parent2", type="class")]
    # Call the function under test
    codeflash_output = convert_parents_to_tuple(src); result = codeflash_output # 4.44μs -> 1.48μs (199% faster)
    # Each element must be a FunctionParent and equal in value to the source element (field-wise equality)
    for orig, conv in zip(src, result):
        pass

def test_conversion_from_tuple_preserves_order_and_values():
    # Use a tuple input instead of a list to verify both input types are supported
    src = (FunctionParent(name="A", type="t1"), FunctionParent(name="B", type="t2"))
    codeflash_output = convert_parents_to_tuple(src); result = codeflash_output # 4.33μs -> 1.35μs (220% faster)

def test_empty_input_returns_empty_tuple():
    # Empty list should produce an empty tuple
    codeflash_output = convert_parents_to_tuple([]) # 1.16μs -> 611ns (90.3% faster)
    # Empty tuple should also produce an empty tuple
    codeflash_output = convert_parents_to_tuple(()) # 561ns -> 281ns (99.6% faster)

def test_special_characters_and_empty_strings_handled_correctly():
    # Names/types with special characters and empty strings should be transferred exactly
    src = [
        FunctionParent(name="", type=""),
        FunctionParent(name="name-with-dash", type="type/with/slash"),
        FunctionParent(name="unicode-✓", type="τ"),
    ]
    codeflash_output = convert_parents_to_tuple(src); result = codeflash_output # 5.45μs -> 1.48μs (267% faster)

def test_invalid_elements_raise_attribute_error():
    # If an element does not expose .name and .type attributes, accessing them should raise AttributeError.
    # Use a list of integers (real built-ins) which lack the required attributes.
    with pytest.raises(AttributeError):
        convert_parents_to_tuple([1, 2, 3]) # 4.34μs -> 6.13μs (29.3% slower)

def test_result_elements_are_frozen_dataclass_instances():
    # Ensure that returned FunctionParent instances are frozen dataclass instances (cannot set attributes).
    src = [FunctionParent(name="p", type="t")]
    codeflash_output = convert_parents_to_tuple(src); result = codeflash_output # 3.61μs -> 1.45μs (148% faster)
    with pytest.raises(AttributeError):
        # Attempt to modify an attribute should raise because dataclass is frozen
        result[0].name = "changed"

def test_conversion_preserves_duplicates_and_order():
    # Ensure duplicates are preserved and order is maintained
    src = [
        FunctionParent(name="dup", type="t1"),
        FunctionParent(name="unique", type="t2"),
        FunctionParent(name="dup", type="t1"),
    ]
    codeflash_output = convert_parents_to_tuple(src); result = codeflash_output # 5.59μs -> 1.56μs (258% faster)

def test_large_scale_single_conversion_of_1000_items():
    # Large-scale test: create 1000 FunctionParent instances and convert once
    large_src = [FunctionParent(name=f"name_{i}", type=f"type_{i % 10}") for i in range(1000)]
    codeflash_output = convert_parents_to_tuple(large_src); result = codeflash_output # 1.15ms -> 46.3μs (2380% faster)

def test_repeated_conversions_1000_iterations_on_medium_list_are_deterministic_and_fast():
    # Run conversion 1000 times on a medium-sized list to assert deterministic behavior under repeated use.
    medium_src = [FunctionParent(name=f"n{i}", type="t") for i in range(100)]
    # Run the conversions in a loop; ensure each iteration produces identical, correct results.
    for _ in range(1000):
        codeflash_output = convert_parents_to_tuple(medium_src); res = codeflash_output # 110ms -> 4.63ms (2291% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from dataclasses import \
    FrozenInstanceError  # to check frozen dataclass behavior

# imports
import pytest  # used for our unit tests
from codeflash.languages.base import convert_parents_to_tuple
# import the real dataclass used by the implementation to construct outputs
from codeflash.models.function_types import FunctionParent

def test_basic_conversion_from_list():
    # Construct real FunctionParent instances as input (use actual constructor).
    parents = [FunctionParent(name="alpha", type="int"), FunctionParent(name="beta", type="str")]
    # Call the function under test.
    codeflash_output = convert_parents_to_tuple(parents); result = codeflash_output # 4.60μs -> 1.51μs (204% faster)

def test_accepts_tuple_input_and_converts():
    # Provide a tuple of FunctionParent objects (the function accepts list or tuple).
    parents = (FunctionParent(name="x", type="XTYPE"),)
    # Call the function.
    codeflash_output = convert_parents_to_tuple(parents); result = codeflash_output # 3.24μs -> 1.28μs (152% faster)

def test_empty_inputs_return_empty_tuple():
    # Empty list should yield empty tuple.
    codeflash_output = convert_parents_to_tuple([]) # 1.17μs -> 631ns (85.7% faster)
    # Empty tuple should also yield empty tuple.
    codeflash_output = convert_parents_to_tuple(()) # 581ns -> 281ns (107% faster)

def test_special_characters_and_empty_strings():
    # Use special characters and empty strings to ensure values are preserved.
    parents = [
        FunctionParent(name="", type=""),  # empty strings
        FunctionParent(name="name with spaces", type="t!@#$%^&*()"),  # special chars and spaces
        FunctionParent(name="unicode-ß-中文", type="typé-✓"),  # unicode characters
    ]
    codeflash_output = convert_parents_to_tuple(parents); result = codeflash_output # 5.56μs -> 1.51μs (267% faster)

def test_returned_functionparent_is_frozen_dataclass():
    # Convert a single element list and verify that attempting to mutate raises FrozenInstanceError.
    codeflash_output = convert_parents_to_tuple([FunctionParent(name="n", type="t")]); result = codeflash_output # 3.02μs -> 1.26μs (140% faster)
    # Confirm the dataclass is frozen by asserting assignment raises the appropriate error.
    with pytest.raises(FrozenInstanceError):
        result[0].name = "mutated"

def test_missing_attributes_raises_attribute_error():
    # If an input element does not have 'name' and 'type' attributes, attribute access should fail.
    # Use a built-in simple object instance which lacks those attributes.
    bad_input = [object()]
    with pytest.raises(AttributeError):
        convert_parents_to_tuple(bad_input) # 4.05μs -> 5.42μs (25.3% slower)

def test_large_scale_conversion_1000_elements():
    # Build 1000 distinct FunctionParent instances.
    large_list = [FunctionParent(name=f"name{i}", type=f"type{(i % 10)}") for i in range(1000)]
    # Convert the large list.
    codeflash_output = convert_parents_to_tuple(large_list); result = codeflash_output # 1.16ms -> 46.0μs (2427% faster)

def test_many_iterations_small_list_1000_iterations():
    # Prepare a small input list and repeatedly convert it 1000 times to exercise repeated usage.
    small_parents = [FunctionParent(name="loopA", type="A"), FunctionParent(name="loopB", type="B")]
    for _ in range(1000):
        codeflash_output = convert_parents_to_tuple(small_parents); res = codeflash_output # 2.80ms -> 536μs (421% 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-pr1561-2026-02-27T01.04.15 and push.