⚡️ Speed up function _contains_jsx by 457% in PR #1567 (codeflash/optimize-pr1563-2026-02-20T03.27.20)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1567

If you approve this dependent PR, these changes will be merged into the original PR branch codeflash/optimize-pr1563-2026-02-20T03.27.20.

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

---

📄 457% (4.57x) speedup for _contains_jsx in codeflash/languages/javascript/frameworks/react/profiler.py

⏱️ Runtime : 621 microseconds → 111 microseconds (best of 31 runs)

📝 Explanation and details

Refined the optimization to focus on the core performance improvement while maximizing code simplicity:

1. Removed module-level _JSX_NODE_TYPES constant: This micro-optimization added complexity (module-level state) without meaningful performance benefit. The original tuple is small and Python handles small tuple membership checks efficiently.

2. Removed reversed(children) and associated comment: For a boolean "contains" check, the traversal order is irrelevant. Removing this simplifies the code and eliminates the overhead of reversing children lists.

3. Kept original variable name node: Reusing node in the loop maintains consistency with the original code and reduces diff size.

4. Removed unnecessary comment: The simplified iterative approach is self-explanatory and doesn't require additional documentation.

The refined code preserves the key optimization (iterative DFS avoiding recursion and generator overhead) while being more readable and closer to the original structure. The performance benefit remains intact as the core algorithmic improvement is preserved.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import argparse  # used to create real Namespace instances for our test nodes

import pytest  # used for our unit tests
from codeflash.languages.javascript.frameworks.react.profiler import \
    _contains_jsx

# Helper to construct node-like objects using a real stdlib class (argparse.Namespace).
# We use argparse.Namespace because it is a real class from the standard library that
# allows us to attach arbitrary attributes (like .type and .children) to instances.
def _make_node(node_type, children=None):
    # Normalize children: if None, use an empty list to represent leaf nodes.
    if children is None:
        children = []
    return argparse.Namespace(type=node_type, children=children)

def test_direct_jsx_types_are_recognized():
    # Create leaf nodes whose .type is directly one of the JSX node types.
    # Each should return True immediately without inspecting children.
    for jsx_type in ("jsx_element", "jsx_self_closing_element", "jsx_fragment"):
        node = _make_node(jsx_type, children=[])
        # The function should identify these node types as containing JSX.
        codeflash_output = _contains_jsx(node) # 983ns -> 1.44μs (31.8% slower)

def test_non_jsx_leaf_returns_false():
    # A leaf node with a non-JSX type and no children must return False.
    leaf = _make_node("identifier", children=[])
    codeflash_output = _contains_jsx(leaf) # 1.43μs -> 982ns (45.8% faster)

def test_nested_jsx_deep_child_is_found():
    # Construct a small tree where the deepest child is a JSX element.
    # root -> child -> grandchild(jsx_element)
    grandchild = _make_node("jsx_element", children=[])
    child = _make_node("call_expression", children=[grandchild])
    root = _make_node("program", children=[child])
    # The function should recurse and find the JSX element in the subtree.
    codeflash_output = _contains_jsx(root) # 2.48μs -> 1.28μs (93.1% faster)

def test_mixed_sibling_nodes_with_one_jsx():
    # Root has multiple children; one sibling is a JSX node.
    child1 = _make_node("identifier", children=[])
    child2 = _make_node("jsx_self_closing_element", children=[])
    child3 = _make_node("literal", children=[])
    root = _make_node("program", children=[child1, child2, child3])
    # The presence of one JSX child should make the whole tree contain JSX.
    codeflash_output = _contains_jsx(root) # 2.40μs -> 1.44μs (66.8% faster)

def test_non_string_type_value_does_not_crash_and_returns_false():
    # If node.type is not a string (but present), membership check shouldn't raise;
    # it should simply evaluate to False and proceed to children.
    node_with_numeric_type = _make_node(12345, children=[])
    codeflash_output = _contains_jsx(node_with_numeric_type) # 1.30μs -> 1.09μs (19.3% faster)

def test_none_input_raises_attribute_error():
    # Passing None (which lacks .type and .children) should raise an AttributeError.
    # This documents the function's expectation of a node-like object.
    with pytest.raises(AttributeError):
        _contains_jsx(None) # 2.71μs -> 3.06μs (11.7% slower)

def test_missing_children_attribute_raises_attribute_error():
    # Create an object that has a .type but lacks .children: use argparse.Namespace
    # but intentionally delete the attribute after creation to simulate a malformed node.
    n = _make_node("identifier", children=[])
    del n.children  # remove children attribute to simulate incomplete node
    with pytest.raises(AttributeError):
        _contains_jsx(n) # 2.92μs -> 2.96μs (1.32% slower)

def test_large_number_of_children_without_jsx_returns_false():
    # Build a root node with 1000 non-JSX direct children to exercise breadth.
    many_children = [_make_node("identifier", children=[]) for _ in range(1000)]
    root = _make_node("root", children=many_children)
    # The function should iterate through all children and conclude there is no JSX.
    codeflash_output = _contains_jsx(root) # 302μs -> 93.4μs (224% faster)

def test_large_number_of_children_with_one_jsx_at_end_returns_true():
    # Build a root with 1000 children where only the last child (deeply nested)
    # contains a JSX node. This verifies the function finds JSX even late in traversal.
    many_children = [_make_node("identifier", children=[]) for _ in range(999)]
    # Make the 1000th child have a small subtree that contains a jsx_element leaf.
    jsx_leaf = _make_node("jsx_element", children=[])
    deep_child = _make_node("call_expression", children=[_make_node("member_expression", children=[jsx_leaf])])
    many_children.append(deep_child)
    root = _make_node("root", children=many_children)
    # The function should still find the JSX element somewhere among many children.
    codeflash_output = _contains_jsx(root) # 302μs -> 4.21μs (7089% 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-pr1567-2026-02-20T03.38.42 and push.

[claude]

PR Review Summary

Prek Checks

✅ All checks passed (ruff check, ruff format). No issues found.

Mypy

✅ No type errors found in the changed file.

Code Review

✅ No critical issues found.

The change converts _contains_jsx from a recursive implementation to an iterative one using an explicit stack. This is a standard recursion-to-iteration refactoring that preserves identical DFS traversal behavior. The optimization eliminates Python function call overhead and avoids potential RecursionError on deeply nested trees.

Test Coverage

File	Stmts	Miss	Coverage	Status
codeflash/languages/javascript/frameworks/react/profiler.py	—	—	0%	⚠️ Not covered
Overall	49,627	10,715	78%	—

Notes:

• profiler.py is a new file introduced in the parent PR chain (does not exist on main). It has no test coverage on either branch, so this optimization PR does not cause a coverage regression.
• The codeflash bot verified correctness with 11 generated regression tests showing 100% coverage of the optimized function.

---

Last updated: 2026-02-20