From e612c2ba7c3bda5011cddf00f84bd8dd6573cefe Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Fri, 20 Feb 2026 03:28:08 +0000
Subject: [PATCH] Optimize _contains_jsx
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The optimized code achieves a **149% speedup** (539μs → 216μs) by replacing recursive tree traversal with an iterative stack-based approach.

## Key Optimization

**Eliminated recursive function calls**: The original implementation used `any(_contains_jsx(child) for child in node.children)`, which created a new stack frame for each recursive call. The line profiler shows this consumed **84.1% of total runtime** (2.23ms out of 2.65ms). The optimized version uses an explicit stack data structure with a while loop, avoiding Python's function call overhead entirely.

## Why This Is Faster

1. **No recursive overhead**: Each recursive call in Python involves creating a new stack frame, copying arguments, and managing return values. The iterative approach eliminates all of this.

2. **Early termination efficiency**: Both versions can return `True` early when JSX is found, but the iterative version does this more efficiently without unwinding the call stack.

3. **Better memory locality**: The explicit stack keeps all traversal state in a single list object, improving CPU cache utilization compared to scattered stack frames.

## Performance Characteristics

The optimization shines particularly well on:
- **Deep nesting**: 100-level deep tree shows **691% speedup** (94.9μs → 12.0μs)
- **Wide trees with JSX at end**: 100 siblings with JSX as last child shows **1985% speedup** (34.3μs → 1.64μs)
- **Balanced trees**: 512-node tree shows **195% speedup** (308μs → 104μs)

Trade-off: Direct JSX matches (root node is JSX) are ~20-26% slower due to stack initialization overhead, but these simple cases are already extremely fast (<1μs) and the optimization dramatically benefits complex real-world AST traversals.

## Impact

For React code analysis tools that traverse Abstract Syntax Trees to detect JSX elements, this optimization significantly reduces profiling overhead, especially when analyzing large component files with deeply nested or wide component trees.
---
 .../languages/javascript/frameworks/react/profiler.py  | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/codeflash/languages/javascript/frameworks/react/profiler.py b/codeflash/languages/javascript/frameworks/react/profiler.py
index f817c375d..1321d0af5 100644
--- a/codeflash/languages/javascript/frameworks/react/profiler.py
+++ b/codeflash/languages/javascript/frameworks/react/profiler.py
@@ -160,9 +160,13 @@ def walk(node: Node) -> None:
 
 def _contains_jsx(node: Node) -> bool:
     """Check if a tree-sitter node contains JSX elements."""
-    if node.type in ("jsx_element", "jsx_self_closing_element", "jsx_fragment"):
-        return True
-    return any(_contains_jsx(child) for child in node.children)
+    stack = [node]
+    while stack:
+        current = stack.pop()
+        if current.type in ("jsx_element", "jsx_self_closing_element", "jsx_fragment"):
+            return True
+        stack.extend(current.children)
+    return False
 
 
 def _wrap_return_with_profiler(source: str, return_node: Node, profiler_id: str, safe_name: str) -> str: