⚡️ Speed up function _get_parent_type_name by 13% in PR #1199 (omni-java)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1199

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

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

---

📄 13% (0.13x) speedup for _get_parent_type_name in codeflash/languages/java/context.py

⏱️ Runtime : 45.0 microseconds → 39.8 microseconds (best of 30 runs)

📝 Explanation and details

The optimized code achieves a 12% runtime improvement by replacing the inline tuple ("ClassDef", "InterfaceDef", "EnumDef") with a module-level frozenset constant _PARENT_TYPE_NAMES.

What changed:

• A frozenset containing the three parent type names is created once at module load time
• The membership test parent.type in _PARENT_TYPE_NAMES now uses the frozenset instead of creating a tuple on each check

Why this is faster:
The key performance gain comes from two factors:

1. Constant instantiation overhead eliminated: The original code creates a new tuple object every time the membership check executes (513 hits in the profile). The optimized version creates the frozenset only once at module load.
2. O(1) hash-based lookup: While the difference is marginal for just 3 elements, frozenset uses hash-based membership testing (O(1) average case) versus tuple's linear scan (O(n)). This provides a small but measurable speedup per check.

Performance characteristics:
The line profiler shows the critical loop line (checking parent.type in ...) executes 513 times and accounts for ~51% of total runtime. Even small per-iteration improvements here compound significantly. The test results confirm this:

• Large-scale benefit: The test_large_scale_parents_last_element_matches test shows a dramatic 27.2% speedup (27.6μs → 21.7μs) when iterating through 500 parents, demonstrating the optimization scales well with larger parent lists
• Small overhead on fast paths: Tests with early returns or no parent iteration show minor slowdowns (3-13%), likely due to cache effects or measurement noise on nanosecond-scale operations
• Overall win: The aggregate 12% speedup indicates the optimization benefits the typical usage pattern where multiple parents are checked

This optimization is particularly valuable if _get_parent_type_name is called frequently during Java code analysis, as the savings multiply across many invocations.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from types import SimpleNamespace  # lightweight real class to hold attributes

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.context import _get_parent_type_name

def test_returns_class_name_when_present():
    # Basic: If class_name is truthy, it should be returned immediately,
    # even if parents are None or would otherwise match.
    func = SimpleNamespace(class_name='MyClass', parents=None)
    # Should return the class_name directly
    codeflash_output = _get_parent_type_name(func) # 881ns -> 802ns (9.85% faster)

def test_prefers_class_name_over_parents_with_matching_parent():
    # Basic: class_name should take precedence over any matching parent in parents list.
    parent = SimpleNamespace(type='ClassDef', name='ParentClass')
    func = SimpleNamespace(class_name='PreferredClass', parents=[parent])
    # Even though a parent matches, class_name wins
    codeflash_output = _get_parent_type_name(func) # 501ns -> 581ns (13.8% slower)

def test_finds_first_matching_parent_type_class_interface_enum():
    # Basic: When class_name is falsy, the function should scan parents and return
    # the first parent whose .type is one of ("ClassDef", "InterfaceDef", "EnumDef").
    p1 = SimpleNamespace(type='Other', name='X')  # non-matching
    p2 = SimpleNamespace(type='InterfaceDef', name='IExample')  # first match
    p3 = SimpleNamespace(type='ClassDef', name='CExample')  # later match
    func = SimpleNamespace(class_name=None, parents=[p1, p2, p3])
    # Should return the name of the first matching parent (p2)
    codeflash_output = _get_parent_type_name(func) # 1.55μs -> 1.70μs (8.81% slower)

def test_returns_none_when_no_class_name_and_no_matching_parents():
    # Edge: Neither class_name nor any parent.type in the allowed set -> None.
    p1 = SimpleNamespace(type='Other', name='X')
    p2 = SimpleNamespace(type='Another', name='Y')
    func = SimpleNamespace(class_name=None, parents=[p1, p2])
    codeflash_output = _get_parent_type_name(func) # 1.03μs -> 1.08μs (4.71% slower)

def test_empty_parents_list_is_handled_and_returns_none():
    # Edge: An empty parents iterable should be falsy and result in None.
    func = SimpleNamespace(class_name=None, parents=[])
    codeflash_output = _get_parent_type_name(func) # 551ns -> 581ns (5.16% slower)

def test_class_name_empty_string_treated_as_missing_and_uses_parents():
    # Edge: An empty string for class_name is falsy; function should check parents.
    parent = SimpleNamespace(type='EnumDef', name='E1')
    func = SimpleNamespace(class_name='', parents=[parent])
    # Since class_name is '', it should be treated as not present and return parent's name
    codeflash_output = _get_parent_type_name(func) # 1.00μs -> 1.06μs (5.65% slower)

def test_parent_type_matching_is_case_sensitive():
    # Edge: The matching checks exact strings. 'classdef' (lowercase) should NOT match.
    parent = SimpleNamespace(type='classdef', name='LowerCaseClass')
    func = SimpleNamespace(class_name=None, parents=[parent])
    # Should not match because of case sensitivity
    codeflash_output = _get_parent_type_name(func) # 932ns -> 962ns (3.12% slower)

def test_parent_with_empty_name_returns_empty_string():
    # Edge: If a matching parent has an empty name (falsy), it should still be returned as-is.
    parent = SimpleNamespace(type='ClassDef', name='')
    func = SimpleNamespace(class_name=None, parents=[parent])
    # The function returns the parent's .name directly, even if it's an empty string
    codeflash_output = _get_parent_type_name(func); result = codeflash_output # 912ns -> 1.00μs (8.98% slower)

def test_parent_object_missing_type_attribute_raises_attribute_error():
    # Edge: If a parent in the iterable lacks the .type attribute, accessing parent.type
    # should raise an AttributeError. This ensures we detect malformed parent items.
    class Bare:  # local bare class used only to create an object without attributes
        pass
    func = SimpleNamespace(class_name=None, parents=[Bare()])
    # Expect AttributeError when the function attempts to access .type
    with pytest.raises(AttributeError):
        _get_parent_type_name(func) # 3.62μs -> 3.79μs (4.52% slower)

def test_parents_not_iterable_raises_type_error():
    # Edge: If parents is truthy but not iterable (e.g., an int), the "for parent in parents"
    # will raise a TypeError. This checks behavior with incorrect types.
    func = SimpleNamespace(class_name=None, parents=12345)  # int is truthy but not iterable
    with pytest.raises(TypeError):
        _get_parent_type_name(func) # 2.38μs -> 2.44μs (2.45% slower)

def test_large_scale_parents_last_element_matches():
    # Large Scale: Ensure function can handle a relatively large parents iterable
    # (well under the 1000-element guideline) and still find a late match.
    size = 500  # under the 1000 limit requested
    # Build a list of non-matching parents
    parents = [SimpleNamespace(type='Other', name=f'nm{i}') for i in range(size)]
    # Append a matching parent at the end
    parents.append(SimpleNamespace(type='ClassDef', name='LastMatch'))
    func = SimpleNamespace(class_name=None, parents=parents)
    # Should return the last matching parent's name
    codeflash_output = _get_parent_type_name(func) # 27.6μs -> 21.7μs (27.2% faster)

def test_large_scale_parents_first_element_matches():
    # Large Scale: If the first element matches, the function should return immediately.
    size = 500
    parents = [SimpleNamespace(type='ClassDef', name='FirstMatch')]
    # Append many non-matching entries afterwards to ensure early return would be beneficial
    parents.extend(SimpleNamespace(type='Other', name=f'xx{i}') for i in range(size))
    func = SimpleNamespace(class_name=None, parents=parents)
    # Should return the first element's name and not be affected by the trailing items
    codeflash_output = _get_parent_type_name(func) # 1.03μs -> 1.19μs (13.4% slower)

def test_non_string_truthy_class_name_is_returned_as_is():
    # Edge: If class_name is a non-string but truthy value (e.g., an int or object),
    # the function returns it as-is since it only checks truthiness.
    func = SimpleNamespace(class_name=12345, parents=[SimpleNamespace(type='ClassDef', name='Ignored')])
    # Should return the non-string truthy class_name unchanged
    codeflash_output = _get_parent_type_name(func) # 551ns -> 591ns (6.77% slower)
# 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-pr1199-2026-02-03T04.05.44 and push.

[KRRT7]

Closing stale bot PR.