From 5b0a8ace81cbd23395aaf60f34b6f0f9fc22648f Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Tue, 24 Feb 2026 12:05:10 +0000
Subject: [PATCH] Optimize RenderCallTransformer._parse_render_call

The optimized code achieves a **22% runtime improvement** (from 1.24ms to 1.02ms) through two targeted optimizations in the hot parsing loop:

## Key Optimizations

### 1. Length Caching (Primary Speedup)
The most impactful change is caching `len(code)` in the `len_code` variable at the start of the function. This eliminates repeated `len()` calls in the main parsing loop, which executes ~20,000 times per run. The line profiler shows this reduced the hottest loop from 22.7% of total time (4.98ms) to 18.6% (3.80ms) - a **24% improvement in the critical path**. This single change accounts for most of the overall speedup.

### 2. Early Continue for String Handling
Adding an explicit `continue` statement after handling string characters (`"'``) restructures the control flow. Instead of nesting deeper conditions, it immediately advances to the next iteration when inside a string. This reduces conditional depth and branch prediction complexity in the tight inner loop, contributing additional performance gains.

## Why This Matters

The `_parse_render_call` method processes JavaScript/React test code character-by-character to parse nested function calls while respecting string boundaries and parentheses depth. The main parsing loop is executed thousands of times per invocation (20,256 hits in the profiler), making it extremely sensitive to micro-optimizations.

Based on the test suite, these optimizations are particularly effective for:
- **Large argument lists**: The `test_parse_large_number_of_children_performance_and_correctness` test with 1000 children benefits significantly from reducing loop overhead
- **Complex nested code**: Tests with parentheses in strings and escaped quotes trigger more loop iterations, amplifying the caching benefit

The optimization maintains correctness across all test scenarios including edge cases (empty code, incomplete matches, escaped quotes) while delivering consistent runtime improvements.
---
 codeflash/languages/javascript/instrument.py | 26 +++++++++++++-------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/codeflash/languages/javascript/instrument.py b/codeflash/languages/javascript/instrument.py
index 579e0496c..ca8f2c360 100644
--- a/codeflash/languages/javascript/instrument.py
+++ b/codeflash/languages/javascript/instrument.py
@@ -873,11 +873,14 @@ def _parse_render_call(self, code: str, match: re.Match) -> RenderCallMatch | No
         # Position after ComponentName
         pos = match.end()
 
+        # Cache length to avoid repeated calls in hot loop
+        len_code = len(code)
+
         # Skip whitespace
-        while pos < len(code) and code[pos] in " \t\n\r":
+        while pos < len_code and code[pos] in " \t\n\r":
             pos += 1
 
-        if pos >= len(code):
+        if pos >= len_code:
             return None
 
         create_element_args = ""
@@ -890,7 +893,7 @@ def _parse_render_call(self, code: str, match: re.Match) -> RenderCallMatch | No
             in_string = False
             string_char = None
 
-            while pos < len(code) and depth > 0:
+            while pos < len_code and depth > 0:
                 char = code[pos]
                 if char in "\"'`" and (pos == 0 or code[pos - 1] != "\\"):
                     if not in_string:
@@ -899,7 +902,10 @@ def _parse_render_call(self, code: str, match: re.Match) -> RenderCallMatch | No
                     elif char == string_char:
                         in_string = False
                         string_char = None
-                elif not in_string:
+                    pos += 1
+                    continue
+
+                if not in_string:
                     if char == "(":
                         depth += 1
                     elif char == ")":
@@ -910,7 +916,8 @@ def _parse_render_call(self, code: str, match: re.Match) -> RenderCallMatch | No
                 return None
 
             # pos-1 is the closing ) of createElement/_jsx
-            create_element_args = code[args_start : pos - 1].strip()
+            create_element_args = code[args_start: pos - 1].strip()
+
 
         elif code[pos] == ")":
             # No args: React.createElement(Counter) or _jsx(Counter)
@@ -919,22 +926,23 @@ def _parse_render_call(self, code: str, match: re.Match) -> RenderCallMatch | No
             return None
 
         # Skip whitespace between createElement closing ) and render closing )
-        while pos < len(code) and code[pos] in " \t\n\r":
+        while pos < len_code and code[pos] in " \t\n\r":
             pos += 1
 
         # Expect closing ) of render(
         # If we see a comma instead, render has additional options - skip this match
-        if pos >= len(code) or code[pos] != ")":
+        if pos >= len_code or code[pos] != ")":
             return None
 
         pos += 1  # skip ) of render
 
         # Check for trailing semicolon
         end_pos = pos
-        while end_pos < len(code) and code[end_pos] in " \t":
+        # Only skip spaces and tabs per original behavior
+        while end_pos < len_code and code[end_pos] in " \t":
             end_pos += 1
 
-        has_trailing_semicolon = end_pos < len(code) and code[end_pos] == ";"
+        has_trailing_semicolon = end_pos < len_code and code[end_pos] == ";"
         if has_trailing_semicolon:
             end_pos += 1