Draft
Conversation
![claude[bot]](https://avatars.githubusercontent.com/in/1236702?s=60&v=4){kind=small}
|
|
||
| # Ensure act import if state updates are detected | ||
| if "act(" in result and "import" in result and "act" not in result.split("from '@testing-library/react'")[0]: | ||
| result = result.replace("from '@testing-library/react'", "act, " + "from '@testing-library/react'", 1) |
Contributor
There was a problem hiding this comment.
Bug: This act injection produces invalid JavaScript syntax.
Given import { render, screen } from '@testing-library/react', this replacement produces:
import { render, screen } act, from '@testing-library/react'
The fix should insert act inside the braces:
Suggested change
| result = result.replace("from '@testing-library/react'", "act, " + "from '@testing-library/react'", 1) | |
| result = result.replace("} from '@testing-library/react'", ", act } from '@testing-library/react'", 1) |
Comment on lines
192
to
211
| return source | ||
|
|
||
| jsx_content = source_bytes[jsx_start:jsx_end].decode("utf-8").strip() | ||
|
|
||
| # Check if the return uses parentheses: return (...) | ||
| # If so, we need to wrap inside the parens | ||
| has_parens = False | ||
| for child in return_node.children: | ||
| if child.type == "parenthesized_expression": | ||
| has_parens = True | ||
| jsx_start = child.start_byte + 1 # skip ( | ||
| jsx_end = child.end_byte - 1 # skip ) | ||
| jsx_content = source_bytes[jsx_start:jsx_end].decode("utf-8").strip() | ||
| break | ||
|
|
||
| wrapped = ( | ||
| f'<React.Profiler id="{profiler_id}" onRender={{_codeflashOnRender_{safe_name}}}>' | ||
| f"\n{jsx_content}\n" | ||
| f"</React.Profiler>" | ||
| ) |
Contributor
There was a problem hiding this comment.
Bug: Byte offsets from tree-sitter (start_byte/end_byte) are used as string indices on source (Python str). This works for ASCII-only source but will produce corrupted output if the source contains multi-byte UTF-8 characters (e.g., Unicode in comments or string literals).
Line 192 correctly uses source_bytes[jsx_start:jsx_end], but line 211 incorrectly uses source[:jsx_start] and source[jsx_end:] with byte offsets on a string.
Fix: Use source_bytes for slicing and decode back:
return source_bytes[:jsx_start].decode("utf-8") + wrapped + source_bytes[jsx_end:].decode("utf-8")The same byte-offset vs string-index mismatch exists in _insert_after_imports (line 225-229).
Comment on lines
+1230
to
+1245
| def _node_has_return(self, node: Node) -> bool: | ||
| """Recursively check if a node contains a return statement.""" | ||
| if node.type == "return_statement": | ||
| return True | ||
|
|
||
| # Don't recurse into nested function definitions | ||
| if node.type in ("function_declaration", "function_expression", "arrow_function", "method_definition"): | ||
| # Only check the current function, not nested ones | ||
| body_node = node.child_by_field_name("body") | ||
| if body_node: | ||
| for child in body_node.children: | ||
| if self._node_has_return(child): | ||
| return True | ||
| return False | ||
|
|
||
| return any(self._node_has_return(child) for child in node.children) |
Contributor
There was a problem hiding this comment.
Bug: _node_has_return incorrectly reports returns from nested functions as belonging to the outer function.
When called on a top-level function, it traverses body children via _node_has_return(child). If child is a nested function, it enters the same function-type branch at line 1236 and searches that nested function's body for returns. A return inside a nested function would propagate True back to the caller, making it appear the outer function has a return.
Example:
function outer() { // No return here
function inner() {
return 42; // This return belongs to inner, not outer
}
}has_return_statement(outer) would incorrectly return True.
Fix: when encountering a nested function node (not the initial call), skip it:
def has_return_statement(self, function_node, source):
body = function_node.node.child_by_field_name("body")
if body:
return self._node_has_return(body)
return False
def _node_has_return(self, node):
if node.type == "return_statement":
return True
if node.type in ("function_declaration", "function_expression", "arrow_function", "method_definition"):
return False # Skip nested functions
return any(self._node_has_return(child) for child in node.children)
Comment on lines
+236
to
+247
| def _ensure_react_import(source: str) -> str: | ||
| """Ensure React is imported (needed for React.Profiler).""" | ||
| if "import React" in source or "import * as React" in source: | ||
| return source | ||
| # Add React import at the top | ||
| if "from 'react'" in source or 'from "react"' in source: | ||
| # React is imported but maybe not as the default. That's fine for JSX. | ||
| # We need React.Profiler so add it | ||
| if "React" not in source.split("from", maxsplit=1)[0] if "from" in source else "": | ||
| return 'import React from "react";\n' + source | ||
| return source | ||
| return 'import React from "react";\n' + source |
Contributor
There was a problem hiding this comment.
Issue: _ensure_react_import has fragile string matching logic.
Line 244's ternary is hard to read and has an edge case: source.split("from", maxsplit=1)[0] splits the entire file on the first occurrence of "from" which could be from a different import, a variable name, or a comment — not necessarily the React import.
For example, if the file starts with:
import { transform } from 'babel';
import { useState } from 'react';The split would be on 'babel''s from, and the check would look for "React" before import { transform }, which wouldn't find it, causing a duplicate import.
Consider matching the specific React import line with a regex instead:
react_import_re = re.compile(r"import\s+.*\bfrom\s+['\"]react['\"]")
Comment on lines
+556
to
+570
| start_line=node.start_point[0] + 1, | ||
| end_line=node.end_point[0] + 1, | ||
| ) | ||
|
|
||
| def _process_import_clause( | ||
| self, | ||
| node: Node, | ||
| source_bytes: bytes, | ||
| default_import: str | None, | ||
| named_imports: list[tuple[str, str | None]], | ||
| namespace_import: str | None, | ||
| ) -> None: | ||
| """Process an import clause to extract imports.""" | ||
| # This is a helper that modifies the lists in place | ||
| # Processing is done inline in _extract_import_info |
Contributor
There was a problem hiding this comment.
Dead code: _process_import_clause is called on line 527 but the method body is empty (only has a docstring comment). All actual processing happens in the for clause_child in child.children loop on lines 529-545 that follows the call.
This dead method should be removed to avoid confusion. If it's intended as a future extension point, add a pass statement and a clear # TODO explaining the intent.
Contributor
PR Review SummaryPrek ChecksStatus: Fixed - All 9 ruff check errors and 1 formatting issue resolved in commit Fixes applied:
Mypy: 26 pre-existing type errors in Code ReviewExisting review comments (all still unfixed):
New issues found (inline comments posted):
Test Coverage
Coverage flags:
Optimization PRs: 8 open PRs from codeflash-ai[bot] (#1562-#1570). All have CI failures beyond Last updated: 2026-02-20T03:50 UTC |
Contributor
⚡️ Codeflash found optimizations for this PR📄 36% (0.36x) speedup for
|
![codeflash-ai[bot]](https://avatars.githubusercontent.com/in/413177?s=60&v=4){kind=small}
Comment on lines
117
to
147
| for match in hook_pattern.finditer(component_source): | ||
| hook_name = match.group(1) | ||
| # Try to determine if there's a dependency array | ||
| # Look for ], [ pattern after the hook call (simplified heuristic) | ||
| rest_of_line = component_source[match.end() :] | ||
| has_deps = False | ||
| dep_count = 0 | ||
|
|
||
| # Simple heuristic: count brackets to find dependency array | ||
| bracket_depth = 1 | ||
| for i, char in enumerate(rest_of_line): | ||
| if char == "(": | ||
| bracket_depth += 1 | ||
| elif char == ")": | ||
| bracket_depth -= 1 | ||
| if bracket_depth == 0: | ||
| # Check if the last argument before closing paren is an array | ||
| preceding = rest_of_line[:i].rstrip() | ||
| if preceding.endswith("]"): | ||
| has_deps = True | ||
| # Count items in the array (rough: count commas + 1 for non-empty) | ||
| array_start = preceding.rfind("[") | ||
| if array_start >= 0: | ||
| array_content = preceding[array_start + 1 : -1].strip() | ||
| if array_content: | ||
| dep_count = array_content.count(",") + 1 | ||
| else: | ||
| dep_count = 0 # empty deps [] | ||
| has_deps = True | ||
| break | ||
|
|
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 17% (0.17x) speedup for _extract_hook_usages in codeflash/languages/javascript/frameworks/react/context.py
⏱️ Runtime : 4.10 milliseconds → 3.52 milliseconds (best of 121 runs)
📝 Explanation and details
This optimization achieves a 16% runtime improvement by eliminating repeated string slicing operations that create temporary substring objects on every hook match.
Key changes:
-
Avoided expensive slicing: The original code created
rest_of_line = component_source[match.end():]for every hook found, copying the remainder of the source string. The optimized version uses absolute indices (start_indexandj) to scan the original string directly without creating temporary substrings. -
Replaced
enumerate()with manual indexing: Changed fromfor i, char in enumerate(rest_of_line)towhile j < s_lenwith manual character access vias[j]. This reduces Python-level overhead from the enumerate iterator and avoids the cost of iterating over a freshly sliced string. -
Backward scanning instead of full slice: Instead of creating
preceding = rest_of_line[:i].rstrip()to check for trailing], the code now scans backward from positionj-1to skip whitespace, checking only the minimal necessary characters. This avoids creating and processing another temporary substring. -
Bounded
rfind()call: The optimized version usess.rfind("[", start_index, k + 1)with explicit bounds rather than searching the entireprecedingslice, making the search more efficient and avoiding the slice allocation.
Performance characteristics:
-
Large inputs see the biggest gains: The test
test_large_number_of_hooks_performance_and_correctness(1000 hooks) shows 42.9% speedup (1.42ms → 994μs), andtest_performance_with_many_non_matching_patterns(500 hooks) shows 56.3% speedup (806μs → 515μs). This is because the per-match slicing overhead compounds dramatically with more hooks. -
Small inputs show modest variation: Tests with 1-3 hooks show mixed results (±2-11%), as the fixed overhead of compilation and setup dominates when there are few matches. The optimization's benefit is most visible when the parsing loop executes many times.
-
Trade-off for dependency parsing: Some tests with complex dependency arrays show slight slowdowns (e.g.,
test_hooks_with_many_dependenciesis 23.5% slower), likely because the boundedrfind()or backward whitespace scanning adds small overhead in edge cases. However, the overall 16% improvement across the full benchmark suite indicates these are outweighed by the gains in the common case.
Why this matters: In React codebases with many hook calls per component, this optimization significantly reduces the parser's memory footprint and improves throughput, making hook analysis faster at scale.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 58 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
# import the function and the HookUsage type from the real module under test
from codeflash.languages.javascript.frameworks.react.context import (
HookUsage, _extract_hook_usages)
def test_no_hooks_returns_empty_list():
# Very simple source with no hook-like identifiers -> expect empty list
src = "function Component() { const x = 1; return x; }"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 4.52μs -> 4.80μs (5.86% slower)
def test_single_hook_no_deps():
# Single hook call with simple argument, no dependency array
src = "const [s, setS] = useState(0);"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 8.19μs -> 7.36μs (11.1% faster)
hu = result[0]
def test_single_hook_with_empty_deps():
# Hook with an explicit empty dependency array
src = "useEffect(() => { doSomething(); }, [])"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 10.3μs -> 10.6μs (2.65% slower)
hu = result[0]
def test_single_hook_with_multiple_deps():
# Hook with several comma-separated dependencies
src = "useEffect(() => { a(); }, [a, b, c])"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 10.3μs -> 10.5μs (2.67% slower)
hu = result[0]
def test_hook_with_nested_parentheses_and_deps():
# Ensure nested parentheses in the first argument do not break detection
src = "useMemo(() => (x) => (y) => y + x, [dep])"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 10.9μs -> 10.9μs (0.558% slower)
hu = result[0]
def test_multiple_hooks_mixed_in_one_source():
# Multiple hooks of different kinds in a single source text,
# including one with deps and one without
src = """
function C() {
const [s] = useState(0);
useEffect(() => { console.log(s); }, [s]);
useRef(null);
}
"""
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 15.5μs -> 15.1μs (2.39% faster)
def test_hook_name_case_sensitivity_and_digits():
# The regex requires an uppercase letter after 'use'. Lowercase should not match.
src = "useeffect(); useA1('x');"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 8.22μs -> 7.36μs (11.7% faster)
def test_dependency_array_on_next_line_and_spaces():
# Dependency array may be on the next line or with extra spaces
src = "useEffect(fn, \n [dep] )"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 9.60μs -> 9.75μs (1.54% slower)
hu = result[0]
def test_false_positive_array_in_inner_argument_counts_as_deps():
# The heuristic looks for a trailing ']' before the closing paren.
# If an inner argument contains an array (but it's not the last arg),
# the heuristic may still treat it as the dependency array.
# This test documents that behavior: the function will mark has_dependency_array True.
src = "useCustom(doSomething([a,b]))"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 8.87μs -> 8.57μs (3.50% faster)
hu = result[0]
def test_no_match_for_lowercase_after_use():
# Confirm that 'use' followed by a lowercase character is not matched
src = "const x = usevalue(1);"
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 4.24μs -> 4.37μs (2.98% slower)
def test_empty_input_returns_empty_list():
# Edge case: empty source string should return no hooks
codeflash_output = _extract_hook_usages(""); result = codeflash_output # 3.06μs -> 3.15μs (2.86% slower)
def test_large_number_of_hooks_performance_and_correctness():
# Construct a large source string with 1000 simple hook calls (no deps)
count = 1000
# Use the correct capitalization 'useState' which the regex will match
src = ";".join("useState({})".format(i) for i in range(count))
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 1.42ms -> 994μs (42.9% faster)
def test_large_mixed_hooks_with_deps_and_nested_parens():
# Build a large source alternating hooks with and without deps,
# and some with nested parentheses to ensure the parser remains correct.
items = []
n = 300 # smaller than 1000 but still large and exercises loops
for i in range(n):
if i % 3 == 0:
# hook with deps
items.append(f"useEffect(() => {{ fn({i}); }}, [d{i}, d{i+1}])")
elif i % 3 == 1:
# hook with nested parentheses but no deps
items.append(f"useMemo(() => ((x) => x + {i})())")
else:
# simple hook
items.append(f"useRef(null)")
src = ";\n".join(items)
codeflash_output = _extract_hook_usages(src); result = codeflash_output # 706μs -> 749μs (5.70% slower)
# Validate a few sampled positions for expected properties
for i in range(0, n, 50):
hu = result[i]
if i % 3 == 0:
pass
elif i % 3 == 1:
pass
else:
pass
# 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 dataclass
# imports
import pytest
from codeflash.languages.javascript.frameworks.react.context import \
_extract_hook_usages
def test_single_hook_with_dependency_array():
"""Test extraction of a single hook with a dependency array."""
source = "useState(initialValue, [value])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.8μs -> 10.8μs (0.566% faster)
def test_single_hook_without_dependency_array():
"""Test extraction of a hook without a dependency array."""
source = "useEffect(() => { console.log('mounted'); })"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.2μs -> 10.3μs (0.594% slower)
def test_multiple_hooks_mixed():
"""Test extraction of multiple hooks with mixed dependency array presence."""
source = "useState(0, []) useEffect(() => {}) useContext(MyContext)"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 13.6μs -> 13.0μs (4.23% faster)
def test_hook_with_multiple_dependencies():
"""Test extraction of a hook with multiple dependencies."""
source = "useState(initialValue, [dep1, dep2, dep3])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.5μs -> 11.0μs (4.01% slower)
def test_hook_with_complex_dependency_expressions():
"""Test extraction of a hook with complex dependency expressions."""
source = "useCallback(() => {}, [state.prop, obj.method(), getValue()])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 11.7μs -> 12.5μs (6.57% slower)
def test_hook_in_assignment():
"""Test extraction of a hook used in an assignment."""
source = "const state = useState(0, [counter])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.55μs -> 9.66μs (1.14% slower)
def test_hook_with_whitespace_variations():
"""Test extraction of hooks with varying whitespace."""
source = "useEffect ( callback , [ dep ] )"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.94μs -> 10.4μs (4.71% slower)
def test_builtin_function_not_matched():
"""Test that built-in functions like useState are not confused with user functions."""
source = "useState(0) versus myFunction()"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 8.14μs -> 7.49μs (8.57% faster)
def test_hook_with_string_literals_containing_parens():
"""Test extraction when hook dependencies contain string literals with parentheses."""
source = "useMemo(() => compute(), ['key(value)'])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.6μs -> 10.8μs (2.50% slower)
def test_custom_hook_extraction():
"""Test extraction of custom hooks following the useXxx naming convention."""
source = "useCustomHook(param1, [dep1, dep2])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.62μs -> 9.84μs (2.24% slower)
def test_empty_source_string():
"""Test extraction from an empty source string."""
source = ""
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 3.01μs -> 3.30μs (8.80% slower)
def test_source_with_no_hooks():
"""Test extraction from source containing no hooks."""
source = "const x = 42; function regularFunction() { return x; }"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 4.40μs -> 4.78μs (7.97% slower)
def test_hook_at_end_of_string_without_closing_paren():
"""Test extraction when hook call is incomplete at end of string."""
source = "useState("
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 6.66μs -> 6.36μs (4.73% faster)
def test_hook_with_empty_dependency_array():
"""Test extraction of a hook with explicitly empty dependency array."""
source = "useEffect(callback, [])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 8.93μs -> 9.06μs (1.44% slower)
def test_hook_with_only_whitespace_in_dependency_array():
"""Test extraction of a hook with only whitespace inside dependency array."""
source = "useEffect(callback, [ ])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.37μs -> 9.27μs (1.09% faster)
def test_nested_function_calls_in_hook():
"""Test extraction when hook arguments contain nested function calls."""
source = "useState(getValue(getInitialValue()))"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.34μs -> 9.29μs (0.538% faster)
def test_hook_with_nested_arrays_in_dependencies():
"""Test extraction when dependency array contains nested arrays."""
source = "useCallback(fn, [[nested, array], item])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.3μs -> 10.5μs (2.37% slower)
def test_hook_name_case_sensitivity():
"""Test that hook matching respects case sensitivity."""
source = "usestate(0) useState(0)"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.82μs -> 7.34μs (6.54% faster)
def test_hook_not_matched_without_capital_letter_after_use():
"""Test that use1stHook pattern is correctly identified."""
source = "use1stHook(value, [dep])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 4.02μs -> 4.33μs (7.16% slower)
def test_hook_with_no_arguments():
"""Test extraction of a hook called with no arguments."""
source = "useContext()"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.35μs -> 6.63μs (10.9% faster)
def test_multiple_hooks_on_same_line():
"""Test extraction of multiple hooks on the same line with various patterns."""
source = "const a = useState(0, [x]); const b = useEffect(() => {}, [y, z])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 13.6μs -> 13.4μs (1.73% faster)
def test_hook_immediately_followed_by_another():
"""Test extraction when hooks are written consecutively."""
source = "useState(0, [])useEffect(() => {}, [x])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 12.3μs -> 12.1μs (1.99% faster)
def test_hook_with_arrow_function_in_dependencies():
"""Test extraction when dependency array contains arrow functions (unusual but possible)."""
source = "useCallback(() => {}, [() => null, other])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.2μs -> 11.0μs (6.93% slower)
def test_hook_with_object_literal_in_dependencies():
"""Test extraction when dependency array contains object literals."""
source = "useMemo(() => {}, [{key: value}, other])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.6μs -> 11.1μs (4.95% slower)
def test_hook_pattern_at_word_boundary():
"""Test that hook pattern respects word boundaries."""
source = "myuseState(0) useStateManager(0) useState(0)"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.1μs -> 9.27μs (9.18% faster)
def test_source_with_only_whitespace():
"""Test extraction from source containing only whitespace."""
source = " \n\t \r\n "
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 3.80μs -> 4.05μs (6.18% slower)
def test_hook_with_comment_in_dependencies():
"""Test extraction when source contains comments (naive parser doesn't strip them)."""
source = "useState(0, [value /* important */])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.3μs -> 10.6μs (3.02% slower)
def test_single_character_hook_name():
"""Test that hook names must have at least 2 characters after 'use'."""
source = "useA()"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.29μs -> 6.29μs (15.9% faster)
def test_very_long_hook_name():
"""Test extraction of a hook with an extremely long name."""
long_hook_name = "use" + "VeryLongCustomHookNameWithManyCharacters" * 5
source = f"{long_hook_name}()"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 7.75μs -> 6.87μs (12.8% faster)
def test_dependency_array_with_trailing_comma():
"""Test extraction of dependency array with trailing comma."""
source = "useEffect(callback, [dep1, dep2,])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 9.93μs -> 10.3μs (3.98% slower)
def test_hook_with_destructured_arguments():
"""Test extraction of hook with destructured arguments."""
source = "useReducer(({ state }, action) => {}, initialState, [init])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 11.3μs -> 12.1μs (6.52% slower)
def test_hook_with_spread_operator_in_dependencies():
"""Test extraction when dependency array uses spread operator."""
source = "useMemo(() => {}, [...dependencies])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 10.1μs -> 10.5μs (3.35% slower)
def test_hook_without_dependency_array_with_trailing_comma():
"""Test hook call with trailing comma but no dependency array."""
source = "useState(0, callback,)"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 8.34μs -> 8.02μs (3.99% faster)
def test_many_hooks_in_single_source():
"""Test extraction of 100 hooks from a single source string."""
# Build a source with 100 different hooks
hooks_list = [f"useHook{i}(value, [dep{i}])" for i in range(100)]
source = " ".join(hooks_list)
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 216μs -> 222μs (2.79% slower)
# Verify all hooks were extracted correctly
for i, hook in enumerate(result):
pass
def test_hooks_with_many_dependencies():
"""Test extraction of hooks with very large dependency arrays."""
# Create a dependency array with 100 items
dependencies = ", ".join([f"dep{i}" for i in range(100)])
source = f"useEffect(callback, [{dependencies}])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 43.4μs -> 56.7μs (23.5% slower)
def test_deeply_nested_function_calls():
"""Test extraction from source with deeply nested function calls."""
# Create 100 levels of nested function calls
nested = "value"
for i in range(100):
nested = f"func{i}({nested})"
source = f"useState({nested}, [state])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 52.1μs -> 67.0μs (22.4% slower)
def test_large_source_with_mixed_content():
"""Test extraction from a large source file with mixed content."""
# Build a large source with hooks, comments, and other code
lines = []
# Add some regular code
for i in range(50):
lines.append(f"const var{i} = {i};")
# Add hooks scattered throughout
for i in range(50):
if i % 2 == 0:
lines.append(f"const hook{i} = useCustomHook{i}(param, [dep{i}]);")
else:
lines.append(f"useEffect{i}(() => {{}}, [dep{i}, other{i}])")
# Add more regular code
for i in range(50):
lines.append(f"function func{i}() {{ return var{i}; }}")
source = "\n".join(lines)
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 164μs -> 176μs (6.57% slower)
def test_hooks_with_very_long_dependency_expressions():
"""Test extraction when dependencies contain very long expressions."""
# Build a long complex dependency
complex_dep = "obj.method().prop.anotherProp.deepMethod().value"
source = f"useMemo(() => {{}}, [{complex_dep}])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 12.3μs -> 13.4μs (8.57% slower)
def test_source_with_1000_character_long_line():
"""Test extraction from source with very long lines."""
# Create a single hook with many dependencies
deps = ", ".join([f"dep{i}" for i in range(250)])
source = f"useHook({' ' * 500}[{deps}])"
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 127μs -> 172μs (25.9% slower)
def test_alternating_hooks_and_non_hooks():
"""Test extraction from source alternating between hooks and non-hook calls."""
# Build source with alternating pattern
parts = []
for i in range(100):
if i % 2 == 0:
parts.append(f"useHook{i}(val, [dep])")
else:
parts.append(f"regularFunc{i}(val)")
source = " ".join(parts)
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 114μs -> 112μs (1.37% faster)
# Verify all found items are hooks
for hook in result:
pass
def test_hooks_with_multiline_dependency_arrays():
"""Test extraction when dependency arrays span multiple lines."""
source = """
useEffect(
callback,
[
dep1,
dep2,
dep3,
dep4,
dep5
]
)
"""
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 15.6μs -> 18.5μs (15.7% slower)
def test_performance_with_many_non_matching_patterns():
"""Test performance when source contains many similar but non-matching patterns."""
# Create source with many patterns that almost match but don't
parts = []
for i in range(500):
parts.append(f"notuse{i}()")
parts.append(f"use{i}()") # Lowercase after 'use'
parts.append(f"useHook{i}()") # Actual matching hooks
source = " ".join(parts)
codeflash_output = _extract_hook_usages(source); result = codeflash_output # 806μs -> 515μs (56.3% faster)
for hook in result:
pass
def test_extraction_consistency_with_repeated_source():
"""Test that extraction produces consistent results when run on same source multiple times."""
source = "useState(0, [x, y]) useEffect(() => {}, [z])"
# Run extraction three times
codeflash_output = _extract_hook_usages(source); result1 = codeflash_output # 13.4μs -> 13.3μs (0.609% faster)
codeflash_output = _extract_hook_usages(source); result2 = codeflash_output # 7.36μs -> 7.33μs (0.423% faster)
codeflash_output = _extract_hook_usages(source); result3 = codeflash_output # 5.80μs -> 5.84μs (0.685% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T03.21.19
Click to see suggested changes
Suggested change
| for match in hook_pattern.finditer(component_source): | |
| hook_name = match.group(1) | |
| # Try to determine if there's a dependency array | |
| # Look for ], [ pattern after the hook call (simplified heuristic) | |
| rest_of_line = component_source[match.end() :] | |
| has_deps = False | |
| dep_count = 0 | |
| # Simple heuristic: count brackets to find dependency array | |
| bracket_depth = 1 | |
| for i, char in enumerate(rest_of_line): | |
| if char == "(": | |
| bracket_depth += 1 | |
| elif char == ")": | |
| bracket_depth -= 1 | |
| if bracket_depth == 0: | |
| # Check if the last argument before closing paren is an array | |
| preceding = rest_of_line[:i].rstrip() | |
| if preceding.endswith("]"): | |
| has_deps = True | |
| # Count items in the array (rough: count commas + 1 for non-empty) | |
| array_start = preceding.rfind("[") | |
| if array_start >= 0: | |
| array_content = preceding[array_start + 1 : -1].strip() | |
| if array_content: | |
| dep_count = array_content.count(",") + 1 | |
| else: | |
| dep_count = 0 # empty deps [] | |
| has_deps = True | |
| break | |
| s = component_source | |
| s_len = len(s) | |
| for match in hook_pattern.finditer(s): | |
| hook_name = match.group(1) | |
| has_deps = False | |
| dep_count = 0 | |
| # Simple heuristic: count brackets to find dependency array | |
| bracket_depth = 1 | |
| # Use absolute indices to avoid slicing the rest_of_line for large inputs | |
| start_index = match.end() | |
| j = start_index | |
| while j < s_len: | |
| char = s[j] | |
| if char == "(": | |
| bracket_depth += 1 | |
| elif char == ")": | |
| bracket_depth -= 1 | |
| if bracket_depth == 0: | |
| # Check if the last argument before closing paren is an array | |
| # Instead of creating the full 'preceding' slice, scan backwards to skip trailing whitespace | |
| k = j - 1 | |
| while k >= start_index and s[k].isspace(): | |
| k -= 1 | |
| if k >= start_index and s[k] == "]": | |
| has_deps = True | |
| # Find the corresponding '[' within the bounds to get the array content | |
| array_start = s.rfind("[", start_index, k + 1) | |
| if array_start >= 0: | |
| # Extract array content between '[' and ']' and trim | |
| array_content = s[array_start + 1 : k].strip() | |
| if array_content: | |
| dep_count = array_content.count(",") + 1 | |
| else: | |
| dep_count = 0 # empty deps [] | |
| has_deps = True | |
| break | |
| j += 1 | |
Contributor
⚡️ Codeflash found optimizations for this PR📄 53% (0.53x) speedup for
|
| # Ensure user-event import if user interactions are tested | ||
| if ( | ||
| "click" in result.lower() or "type" in result.lower() or "userEvent" in result | ||
| ) and "@testing-library/user-event" not in result: |
Contributor
There was a problem hiding this comment.
Bug: "type" in result.lower() will match virtually every TypeScript test file (type annotations, componentType, etc.), causing a spurious userEvent import to be added to most generated tests. Consider matching on more specific patterns like userEvent.click or userEvent.type instead of bare keyword matching.
Suggested change
| ) and "@testing-library/user-event" not in result: | |
| if "userevent.click" in result.lower() or "userevent.type" in result.lower(): |
| return self.original_avg_duration_ms / self.optimized_avg_duration_ms | ||
|
|
||
|
|
||
| def compare_render_benchmarks( |
Contributor
There was a problem hiding this comment.
Bug: When the optimized duration is 0 (best possible outcome - render time eliminated entirely), this returns 0.0 instead of a high value. This means format_render_benchmark_for_pr won't display the speedup (benchmark.render_speedup_x > 1 is False), even though the optimization completely eliminated render time.
Suggested change
| def compare_render_benchmarks( | |
| if self.optimized_avg_duration_ms == 0: | |
| return float("inf") if self.original_avg_duration_ms > 0 else 1.0 |
| result = source | ||
| # Process in reverse order by start_line to preserve positions | ||
| for comp in sorted(components, key=lambda c: c.start_line, reverse=True): | ||
| if comp.returns_jsx: |
Contributor
There was a problem hiding this comment.
Bug: Each call to instrument_component_with_profiler re-parses the source and inserts render counter code after imports via _insert_after_imports. After the first component is instrumented, the source is modified (code prepended at top), making all subsequent byte offsets from the original find_react_components stale. Processing in reverse by start_line helps for within-function edits, but _insert_after_imports shifts everything, so the second+ components will have profiler wrappers at wrong positions.
Consider collecting all components, then doing a single-pass instrumentation, or re-parsing after each component.
Comment on lines
+62
to
+71
| # Aggregate original metrics | ||
| orig_count = max((p.render_count for p in original_profiles), default=0) | ||
| orig_durations = [p.actual_duration_ms for p in original_profiles] | ||
| orig_avg_duration = sum(orig_durations) / len(orig_durations) if orig_durations else 0.0 | ||
|
|
||
| # Aggregate optimized metrics | ||
| opt_count = max((p.render_count for p in optimized_profiles), default=0) | ||
| opt_durations = [p.actual_duration_ms for p in optimized_profiles] | ||
| opt_avg_duration = sum(opt_durations) / len(opt_durations) if opt_durations else 0.0 | ||
|
|
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 57% (0.57x) speedup for compare_render_benchmarks in codeflash/languages/javascript/frameworks/react/benchmarking.py
⏱️ Runtime : 979 microseconds → 624 microseconds (best of 140 runs)
📝 Explanation and details
The optimized code achieves a 56% runtime improvement by replacing multiple passes over the profile lists with single-pass aggregation.
Key Changes:
-
Eliminated intermediate list creation: The original code created temporary lists (
orig_durations,opt_durations) and then calledsum()on them, requiring two full passes through each profile list. -
Single-pass aggregation: The optimized version processes each profile list once, accumulating the total duration and tracking the maximum render count simultaneously in a single loop.
-
Reduced built-in overhead: Avoided the overhead of the
max()built-in with generator expressions, which had to iterate through all profiles to find the maximum. The optimized code tracks the maximum during the single pass with simple comparison operations.
Performance Impact:
The line profiler shows the optimization particularly benefits workloads with many profiles:
- For 1000+ profile lists: ~31-46% faster
- For smaller lists (1-10 profiles): ~90-110% faster
- The improvement scales with list size as it avoids the overhead of multiple iterations
Why It's Faster:
In Python, list comprehensions and generator expressions with max()/sum() each require a full traversal of the input data. By combining max-finding and sum calculation into a single loop, we:
- Reduce the number of Python bytecode operations
- Improve cache locality by processing each profile object once
- Eliminate temporary list allocations
Context from References:
The function is called in integration tests processing React component render profiles. Given it processes aggregated profiling data that could contain hundreds of render events per component, the single-pass optimization provides meaningful speedup in the benchmarking pipeline where these comparisons run repeatedly during optimization workflows.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 139 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
from codeflash.languages.javascript.frameworks.react.benchmarking import (
RenderBenchmark, compare_render_benchmarks)
# import the real classes and function under test from the package
from codeflash.languages.javascript.parse import RenderProfile
def test_empty_lists_return_none():
# If either input list is empty the function should return None
# Prepare an example profile to use in one of the parameters
rp = RenderProfile("Button", "mount", 12.0, 10.0, 1)
# original empty
codeflash_output = compare_render_benchmarks([], [rp]); res = codeflash_output # 410ns -> 431ns (4.87% slower)
# optimized empty
codeflash_output = compare_render_benchmarks([rp], []); res = codeflash_output # 300ns -> 290ns (3.45% faster)
# both empty
codeflash_output = compare_render_benchmarks([], []); res = codeflash_output # 170ns -> 170ns (0.000% faster)
def test_single_profile_each_basic_aggregation():
# Simple case: one original and one optimized profile
orig = RenderProfile("MyComponent", "mount", 25.5, 20.0, 2)
opt = RenderProfile("MyComponent", "update", 10.0, 9.0, 1)
codeflash_output = compare_render_benchmarks([orig], [opt]); bench = codeflash_output # 6.04μs -> 2.96μs (104% faster)
def test_multiple_profiles_aggregation_and_component_name_choice():
# Multiple original profiles: check max(render_count) and average(actual_duration_ms)
originals = [
RenderProfile("Primary", "mount", 10.0, 9.0, 1),
RenderProfile("Primary-ALT", "update", 30.0, 28.0, 3),
RenderProfile("Primary", "update", 20.0, 19.0, 2),
]
# Multiple optimized profiles with different component names to ensure original[0] wins
optimized = [
RenderProfile("Other", "update", 5.0, 5.0, 2),
RenderProfile("Other", "update", 15.0, 14.0, 4),
]
codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 6.22μs -> 3.07μs (103% faster)
def test_zero_and_negative_durations_and_counts():
# Ensure function handles zero and negative durations gracefully (mathematical average)
originals = [
RenderProfile("EdgeCase", "mount", 0.0, 0.0, 0),
RenderProfile("EdgeCase", "update", -5.0, -5.0, 0),
]
optimized = [
RenderProfile("EdgeCase", "mount", 0.0, 0.0, 0),
]
codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 5.70μs -> 2.81μs (103% faster)
def test_phase_values_do_not_affect_aggregation():
# Different phase strings should not affect aggregation logic
originals = [
RenderProfile("PhaseComp", "mount", 2.0, 1.0, 1),
RenderProfile("PhaseComp", "update", 8.0, 7.0, 2),
]
optimized = [
RenderProfile("PhaseComp", "mount", 5.0, 4.0, 1),
RenderProfile("PhaseComp", "update", 7.0, 6.0, 3),
]
codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 5.80μs -> 2.82μs (106% faster)
def test_component_name_with_special_characters():
# Component names containing punctuation and whitespace are preserved
name = "Comp v2.0 - test_case/α" # includes punctuation and non-ascii character
originals = [RenderProfile(name, "mount", 3.0, 3.0, 1)]
optimized = [RenderProfile(name, "update", 1.0, 1.0, 1)]
codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 5.40μs -> 2.57μs (110% faster)
def test_large_scale_aggregation_1000_elements_original_and_optimized():
# Create 1000 original profiles with durations 1..1000 and render_count equal to the index
originals = [
RenderProfile("BigComp", "update", float(i), 0.0, i) for i in range(1, 1001)
]
# Create 1000 optimized profiles with durations 1001..2000 and render_count equal to index+1000
optimized = [
RenderProfile("BigComp", "update", float(1000 + i), 0.0, 1000 + i)
for i in range(1, 1001)
]
codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 128μs -> 108μs (19.0% faster)
def test_large_scale_with_repeated_values_and_max_check():
# 1000 items where render_count cycles but we ensure a known max exists
# Use render_count = i % 37 and include one item with a much larger count to set the max
originals = [
RenderProfile("CycleComp", "mount", float(i % 10), 0.0, i % 37) for i in range(1000)
]
# Insert one outlier with very large render_count at the beginning (to also test component_name)
originals.insert(0, RenderProfile("CycleComp", "mount", 0.0, 0.0, 9999))
optimized = [
RenderProfile("CycleComp", "update", 5.0, 0.0, 0) for _ in range(1000)
]
codeflash_output = compare_render_benchmarks(originals, optimized); bench = codeflash_output # 126μs -> 86.8μs (46.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.import pytest
from codeflash.languages.javascript.frameworks.react.benchmarking import (
RenderBenchmark, compare_render_benchmarks)
from codeflash.languages.javascript.parse import RenderProfile
def test_compare_render_benchmarks_basic_single_profile_each():
"""Test basic comparison with one profile in each list."""
original = [
RenderProfile(
component_name="Button",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=3.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Button",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.59μs -> 2.75μs (103% faster)
def test_compare_render_benchmarks_multiple_profiles_both_lists():
"""Test comparison with multiple profiles in each list."""
original = [
RenderProfile(
component_name="Modal",
phase="mount",
actual_duration_ms=10.0,
base_duration_ms=8.0,
render_count=2,
),
RenderProfile(
component_name="Modal",
phase="update",
actual_duration_ms=8.0,
base_duration_ms=6.0,
render_count=3,
),
]
optimized = [
RenderProfile(
component_name="Modal",
phase="mount",
actual_duration_ms=6.0,
base_duration_ms=5.0,
render_count=2,
),
RenderProfile(
component_name="Modal",
phase="update",
actual_duration_ms=4.0,
base_duration_ms=3.0,
render_count=2,
),
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.91μs -> 2.87μs (106% faster)
def test_compare_render_benchmarks_uses_first_component_name():
"""Test that the function uses the first profile's component name."""
original = [
RenderProfile(
component_name="Component1",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Component1",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.30μs -> 2.69μs (96.7% faster)
def test_compare_render_benchmarks_returns_render_benchmark_type():
"""Test that the return type is RenderBenchmark."""
original = [
RenderProfile(
component_name="Test",
phase="mount",
actual_duration_ms=1.0,
base_duration_ms=1.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Test",
phase="mount",
actual_duration_ms=1.0,
base_duration_ms=1.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.24μs -> 2.63μs (98.9% faster)
def test_compare_render_benchmarks_zero_duration_values():
"""Test with zero duration values."""
original = [
RenderProfile(
component_name="Fast",
phase="mount",
actual_duration_ms=0.0,
base_duration_ms=0.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Fast",
phase="mount",
actual_duration_ms=0.0,
base_duration_ms=0.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.21μs -> 2.57μs (102% faster)
def test_compare_render_benchmarks_very_small_float_values():
"""Test with very small floating point values."""
original = [
RenderProfile(
component_name="Micro",
phase="mount",
actual_duration_ms=0.001,
base_duration_ms=0.001,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Micro",
phase="mount",
actual_duration_ms=0.0005,
base_duration_ms=0.0005,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.28μs -> 2.60μs (103% faster)
def test_compare_render_benchmarks_large_duration_values():
"""Test with very large duration values."""
original = [
RenderProfile(
component_name="Slow",
phase="mount",
actual_duration_ms=10000.5,
base_duration_ms=9999.5,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Slow",
phase="mount",
actual_duration_ms=5000.25,
base_duration_ms=4999.75,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.22μs -> 2.53μs (106% faster)
def test_compare_render_benchmarks_high_render_count():
"""Test with high render counts."""
original = [
RenderProfile(
component_name="Expensive",
phase="mount",
actual_duration_ms=2.0,
base_duration_ms=1.0,
render_count=1000,
)
]
optimized = [
RenderProfile(
component_name="Expensive",
phase="mount",
actual_duration_ms=1.0,
base_duration_ms=0.5,
render_count=500,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.27μs -> 2.60μs (102% faster)
def test_compare_render_benchmarks_empty_original_list_returns_none():
"""Test that empty original_profiles list returns None."""
original = []
optimized = [
RenderProfile(
component_name="Button",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 431ns -> 411ns (4.87% faster)
def test_compare_render_benchmarks_empty_optimized_list_returns_none():
"""Test that empty optimized_profiles list returns None."""
original = [
RenderProfile(
component_name="Button",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=3.0,
render_count=1,
)
]
optimized = []
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 421ns -> 441ns (4.54% slower)
def test_compare_render_benchmarks_both_lists_empty_returns_none():
"""Test that both lists being empty returns None."""
original = []
optimized = []
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 411ns -> 400ns (2.75% faster)
def test_compare_render_benchmarks_special_characters_in_component_name():
"""Test with special characters in component name."""
original = [
RenderProfile(
component_name="Button-Primary_V2.0",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Button-Primary_V2.0",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.64μs -> 2.77μs (104% faster)
def test_compare_render_benchmarks_unicode_component_name():
"""Test with unicode characters in component name."""
original = [
RenderProfile(
component_name="按钮",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="按钮",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.32μs -> 2.60μs (104% faster)
def test_compare_render_benchmarks_render_count_zero():
"""Test with zero render count."""
original = [
RenderProfile(
component_name="Test",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=0,
)
]
optimized = [
RenderProfile(
component_name="Test",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=0,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.25μs -> 2.60μs (102% faster)
def test_compare_render_benchmarks_negative_duration_values():
"""Test with negative duration values (edge case, though unlikely in real use)."""
original = [
RenderProfile(
component_name="Negative",
phase="mount",
actual_duration_ms=-1.0,
base_duration_ms=-1.0,
render_count=1,
)
]
optimized = [
RenderProfile(
component_name="Negative",
phase="mount",
actual_duration_ms=-0.5,
base_duration_ms=-0.5,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.24μs -> 2.62μs (99.6% faster)
def test_compare_render_benchmarks_max_render_count_used():
"""Test that max render_count is correctly selected."""
original = [
RenderProfile(
component_name="MaxTest",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=10,
),
RenderProfile(
component_name="MaxTest",
phase="update",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=50,
),
RenderProfile(
component_name="MaxTest",
phase="update",
actual_duration_ms=2.0,
base_duration_ms=1.0,
render_count=30,
),
]
optimized = [
RenderProfile(
component_name="MaxTest",
phase="mount",
actual_duration_ms=2.0,
base_duration_ms=1.0,
render_count=5,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.75μs -> 2.90μs (98.0% faster)
def test_compare_render_benchmarks_average_duration_calculation():
"""Test that average duration is correctly calculated."""
original = [
RenderProfile(
component_name="Avg",
phase="mount",
actual_duration_ms=10.0,
base_duration_ms=8.0,
render_count=1,
),
RenderProfile(
component_name="Avg",
phase="update",
actual_duration_ms=20.0,
base_duration_ms=16.0,
render_count=2,
),
RenderProfile(
component_name="Avg",
phase="update",
actual_duration_ms=30.0,
base_duration_ms=24.0,
render_count=3,
),
]
optimized = [
RenderProfile(
component_name="Avg",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=1,
),
RenderProfile(
component_name="Avg",
phase="update",
actual_duration_ms=10.0,
base_duration_ms=8.0,
render_count=2,
),
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.78μs -> 2.87μs (102% faster)
def test_compare_render_benchmarks_different_phases_handled():
"""Test that different phase values are handled correctly."""
original = [
RenderProfile(
component_name="Component",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=1,
),
RenderProfile(
component_name="Component",
phase="update",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
),
]
optimized = [
RenderProfile(
component_name="Component",
phase="mount",
actual_duration_ms=2.0,
base_duration_ms=1.0,
render_count=1,
),
RenderProfile(
component_name="Component",
phase="update",
actual_duration_ms=1.0,
base_duration_ms=0.5,
render_count=1,
),
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.68μs -> 2.79μs (104% faster)
def test_compare_render_benchmarks_single_very_long_list_original():
"""Test with many profiles in original list."""
original = [
RenderProfile(
component_name="LongList",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float(i),
base_duration_ms=float(i - 1),
render_count=i + 1,
)
for i in range(1, 11)
]
optimized = [
RenderProfile(
component_name="LongList",
phase="mount",
actual_duration_ms=1.0,
base_duration_ms=1.0,
render_count=1,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 6.16μs -> 3.24μs (90.4% faster)
# Average: (1 + 2 + 3 + ... + 10) / 10 = 5.5
expected_avg = sum(range(1, 11)) / 10
def test_compare_render_benchmarks_three_profiles_average():
"""Test average calculation with exactly three profiles."""
original = [
RenderProfile(
component_name="Three",
phase="mount",
actual_duration_ms=9.0,
base_duration_ms=8.0,
render_count=1,
),
RenderProfile(
component_name="Three",
phase="update",
actual_duration_ms=12.0,
base_duration_ms=11.0,
render_count=2,
),
RenderProfile(
component_name="Three",
phase="update",
actual_duration_ms=15.0,
base_duration_ms=14.0,
render_count=3,
),
]
optimized = [
RenderProfile(
component_name="Three",
phase="mount",
actual_duration_ms=3.0,
base_duration_ms=2.0,
render_count=1,
),
RenderProfile(
component_name="Three",
phase="update",
actual_duration_ms=6.0,
base_duration_ms=5.0,
render_count=2,
),
RenderProfile(
component_name="Three",
phase="update",
actual_duration_ms=9.0,
base_duration_ms=8.0,
render_count=3,
),
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.69μs -> 2.96μs (92.6% faster)
def test_compare_render_benchmarks_many_profiles_original():
"""Test with 100 profiles in original list."""
original = [
RenderProfile(
component_name="LargeComponent",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float(i % 50 + 1),
base_duration_ms=float((i % 50)),
render_count=(i % 100) + 1,
)
for i in range(100)
]
optimized = [
RenderProfile(
component_name="LargeComponent",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=10,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 12.6μs -> 8.00μs (57.4% faster)
# Verify that the aggregation works correctly
expected_max_render = max((i % 100) + 1 for i in range(100))
def test_compare_render_benchmarks_many_profiles_optimized():
"""Test with 100 profiles in optimized list."""
original = [
RenderProfile(
component_name="OptimizedComponent",
phase="mount",
actual_duration_ms=10.0,
base_duration_ms=8.0,
render_count=50,
)
]
optimized = [
RenderProfile(
component_name="OptimizedComponent",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float(i % 30 + 1),
base_duration_ms=float((i % 30)),
render_count=(i % 80) + 1,
)
for i in range(100)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 12.3μs -> 7.86μs (56.2% faster)
# Verify that the aggregation works correctly
expected_max_render = max((i % 80) + 1 for i in range(100))
def test_compare_render_benchmarks_both_lists_many_profiles():
"""Test with 100 profiles in both lists."""
original = [
RenderProfile(
component_name="DoubleScale",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float(i % 40 + 2),
base_duration_ms=float((i % 40) + 1),
render_count=(i % 120) + 1,
)
for i in range(100)
]
optimized = [
RenderProfile(
component_name="DoubleScale",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float(i % 20 + 1),
base_duration_ms=float((i % 20)),
render_count=(i % 60) + 1,
)
for i in range(100)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 18.6μs -> 12.8μs (45.2% faster)
# Verify maximum render counts
original_max = max((i % 120) + 1 for i in range(100))
optimized_max = max((i % 60) + 1 for i in range(100))
def test_compare_render_benchmarks_1000_profiles_original():
"""Test with 1000 profiles in original list for scalability."""
original = [
RenderProfile(
component_name="Scalable",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float((i % 100) + 1),
base_duration_ms=float((i % 100)),
render_count=(i % 500) + 1,
)
for i in range(1000)
]
optimized = [
RenderProfile(
component_name="Scalable",
phase="mount",
actual_duration_ms=50.0,
base_duration_ms=49.0,
render_count=250,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 66.9μs -> 51.0μs (31.3% faster)
def test_compare_render_benchmarks_1000_profiles_optimized():
"""Test with 1000 profiles in optimized list for scalability."""
original = [
RenderProfile(
component_name="ScalableOpt",
phase="mount",
actual_duration_ms=100.0,
base_duration_ms=98.0,
render_count=500,
)
]
optimized = [
RenderProfile(
component_name="ScalableOpt",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float((i % 50) + 1),
base_duration_ms=float((i % 50)),
render_count=(i % 250) + 1,
)
for i in range(1000)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 66.2μs -> 47.3μs (40.0% faster)
def test_compare_render_benchmarks_1000_profiles_both_lists():
"""Test with 1000 profiles in both lists for scalability."""
original = [
RenderProfile(
component_name="FullScale",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float((i % 75) + 3),
base_duration_ms=float((i % 75) + 2),
render_count=(i % 300) + 1,
)
for i in range(1000)
]
optimized = [
RenderProfile(
component_name="FullScale",
phase="mount" if i % 2 == 0 else "update",
actual_duration_ms=float((i % 40) + 1),
base_duration_ms=float((i % 40)),
render_count=(i % 150) + 1,
)
for i in range(1000)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 126μs -> 92.0μs (37.6% faster)
def test_compare_render_benchmarks_identical_profiles():
"""Test comparison when original and optimized are identical."""
profiles = [
RenderProfile(
component_name="Identical",
phase="mount",
actual_duration_ms=7.5,
base_duration_ms=6.5,
render_count=5,
),
RenderProfile(
component_name="Identical",
phase="update",
actual_duration_ms=4.5,
base_duration_ms=3.5,
render_count=10,
),
]
codeflash_output = compare_render_benchmarks(profiles, profiles); result = codeflash_output # 6.00μs -> 2.90μs (107% faster)
def test_compare_render_benchmarks_precision_float_arithmetic():
"""Test floating point precision in average calculations."""
original = [
RenderProfile(
component_name="Precision",
phase="mount",
actual_duration_ms=1.1,
base_duration_ms=1.0,
render_count=1,
),
RenderProfile(
component_name="Precision",
phase="update",
actual_duration_ms=2.2,
base_duration_ms=2.0,
render_count=2,
),
RenderProfile(
component_name="Precision",
phase="update",
actual_duration_ms=3.3,
base_duration_ms=3.0,
render_count=3,
),
]
optimized = [
RenderProfile(
component_name="Precision",
phase="mount",
actual_duration_ms=0.5,
base_duration_ms=0.4,
render_count=1,
),
RenderProfile(
component_name="Precision",
phase="update",
actual_duration_ms=0.6,
base_duration_ms=0.5,
render_count=2,
),
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 5.79μs -> 2.75μs (110% faster)
def test_compare_render_benchmarks_100_identical_profiles():
"""Test with 100 identical profiles in both lists."""
profiles = [
RenderProfile(
component_name="Uniform",
phase="mount",
actual_duration_ms=5.0,
base_duration_ms=4.0,
render_count=10,
)
for _ in range(100)
]
codeflash_output = compare_render_benchmarks(profiles, profiles); result = codeflash_output # 18.3μs -> 10.7μs (70.9% faster)
def test_compare_render_benchmarks_performance_many_iterations():
"""Test performance by creating many different component comparisons."""
for iteration in range(100):
original = [
RenderProfile(
component_name=f"Component_{iteration}",
phase="mount",
actual_duration_ms=5.0 + iteration,
base_duration_ms=4.0 + iteration,
render_count=10 + iteration,
)
]
optimized = [
RenderProfile(
component_name=f"Component_{iteration}",
phase="mount",
actual_duration_ms=3.0 + iteration,
base_duration_ms=2.0 + iteration,
render_count=5 + iteration,
)
]
codeflash_output = compare_render_benchmarks(original, optimized); result = codeflash_output # 265μs -> 131μs (103% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T03.48.17
Click to see suggested changes
Suggested change
| # Aggregate original metrics | |
| orig_count = max((p.render_count for p in original_profiles), default=0) | |
| orig_durations = [p.actual_duration_ms for p in original_profiles] | |
| orig_avg_duration = sum(orig_durations) / len(orig_durations) if orig_durations else 0.0 | |
| # Aggregate optimized metrics | |
| opt_count = max((p.render_count for p in optimized_profiles), default=0) | |
| opt_durations = [p.actual_duration_ms for p in optimized_profiles] | |
| opt_avg_duration = sum(opt_durations) / len(opt_durations) if opt_durations else 0.0 | |
| # Aggregate original metrics in a single pass | |
| orig_count = 0 | |
| orig_total_duration = 0.0 | |
| orig_len = len(original_profiles) | |
| for p in original_profiles: | |
| orig_total_duration += p.actual_duration_ms | |
| if p.render_count > orig_count: | |
| orig_count = p.render_count | |
| orig_avg_duration = orig_total_duration / orig_len if orig_len else 0.0 | |
| # Aggregate optimized metrics in a single pass | |
| opt_count = 0 | |
| opt_total_duration = 0.0 | |
| opt_len = len(optimized_profiles) | |
| for p in optimized_profiles: | |
| opt_total_duration += p.actual_duration_ms | |
| if p.render_count > opt_count: | |
| opt_count = p.render_count | |
| opt_avg_duration = opt_total_duration / opt_len if opt_len else 0.0 | |
This optimization achieves a **12% runtime improvement** (from 3.47ms to 3.08ms) by eliminating redundant work in React component analysis. The key changes deliver measurable performance gains: ## Primary Optimizations **1. Module-level Regex Compilation** The original code recompiled three regular expressions on every function call: - `_extract_hook_usages`: compiled `_HOOK_PATTERN` on each invocation - `_extract_child_components`: compiled `_JSX_COMPONENT_RE` on each invocation - `_extract_context_subscriptions`: compiled `_CONTEXT_RE` on each invocation Moving these to module-level constants (`_HOOK_PATTERN`, `_JSX_COMPONENT_RE`, `_CONTEXT_RE`) eliminates this overhead. Line profiler data shows this saves ~25ms per call to `_extract_hook_usages` and similar savings in other functions (e.g., `_extract_child_components` dropped from 1.48ms to 1.10ms). **2. Index-based Iteration in `_extract_hook_usages`** The original code created a new substring `rest_of_line = component_source[match.end():]` for every hook match, then performed string operations on it. With 672 hooks detected in the test workload, this created 672 unnecessary string allocations. The optimized version iterates by index through the original string (`while j < n: char = cs[j]`), avoiding substring creation. This reduces string slicing operations and memory allocations, contributing to the overall runtime improvement. **3. Eliminated Repeated Import** Removed `import re` statements from function bodies, preventing import overhead on every call (though Python caches imports, the lookup still has cost). ## Performance Impact by Test Case The optimization shows consistent improvements across workloads: - **Small components**: 9-47% faster (basic hook extraction, empty source) - **Medium complexity**: 7-12% faster (multiple hooks, optimization detection) - **Large scale (500+ elements)**: 12.5% faster - demonstrates excellent scaling as the regex compilation savings compound with more matches ## Workload Context Based on `function_references`, this code runs in an integration test that analyzes real React components (e.g., TaskList.tsx). The function extracts hooks, child components, and optimization opportunities - operations that can be called repeatedly during codebase analysis. The 12% runtime improvement means faster analysis cycles when processing multiple components or large codebases. The optimization particularly benefits scenarios with: - Many hook calls per component (common in modern React) - Multiple component analyses in sequence (the module-level regex stays compiled) - Large component source files (index-based iteration avoids O(n²) substring creation)
Contributor
⚡️ Codeflash found optimizations for this PR📄 12% (0.12x) speedup for
|
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Contributor
⚡️ Codeflash found optimizations for this PR📄 3,021% (30.21x) speedup for
|
…2026-02-20T03.56.09 ⚡️ Speed up function `extract_react_context` by 12% in PR #1561 (`add/support_react`)
Contributor
|
This PR is now faster! 🚀 @claude[bot] accepted my optimizations from: |
|
|
||
| def _extract_context_subscriptions(component_source: str) -> list[str]: | ||
| """Find React context subscriptions via useContext calls.""" | ||
| return [match.group(1) for match in _CONTEXT_RE.finditer(component_source)] |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 31% (0.31x) speedup for _extract_context_subscriptions in codeflash/languages/javascript/frameworks/react/context.py
⏱️ Runtime : 2.09 milliseconds → 1.60 milliseconds (best of 250 runs)
📝 Explanation and details
The optimized code achieves a 31% runtime improvement by replacing a list comprehension with finditer() and match.group(1) calls with the built-in re.findall() method.
Key Change:
- Original:
[match.group(1) for match in _CONTEXT_RE.finditer(component_source)] - Optimized:
_CONTEXT_RE.findall(component_source)
Why This Is Faster:
-
Reduced Python-Level Overhead: The original approach creates a Python iterator (
finditer), then for each match object calls the.group(1)method in Python. The optimized version usesfindall(), which is implemented in C and directly returns captured groups, eliminating multiple Python method calls and iterator protocol overhead. -
More Efficient Memory Allocation:
findall()builds the result list internally in C code with optimized memory allocation patterns, whereas the list comprehension allocates and resizes the list incrementally as it processes each match object. -
Direct Capture Group Extraction: Since the regex has exactly one capture group
(\w+),findall()automatically extracts just that group for each match, which is precisely what the original code was doing manually withmatch.group(1).
Test Results Analysis:
- Small inputs (single matches): 58-88% faster, showing significant overhead reduction even for trivial cases
- Multiple matches: 47-89% faster across various test cases
- Large-scale tests (100-1000 matches): 6-66% faster, with the benefit scaling well with input size
- Edge cases: Consistently faster across empty inputs, non-matching patterns, and various whitespace configurations
Impact on Workloads:
Based on the function_references, this function is called during React component analysis to identify context subscriptions. The optimization is particularly valuable when:
- Analyzing large React codebases with many components
- Processing components with multiple
useContextcalls - Running batch analysis operations where this function is called repeatedly
The 31% runtime improvement means faster React code analysis pipelines, reduced latency in development tools, and better scalability for large projects—all without changing the function's behavior or API.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 49 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
from codeflash.languages.javascript.frameworks.react.context import \
_extract_context_subscriptions
def test_single_match_basic():
# Simple usage: capture a single identifier passed to useContext.
src = "const ctx = useContext(MyContext);"
# Expect the captured identifier to be returned in a list.
codeflash_output = _extract_context_subscriptions(src) # 4.21μs -> 2.35μs (78.7% faster)
def test_multiple_matches_and_whitespace():
# Several useContext calls with varied whitespace and identifier forms.
src = """
const a = useContext( Alpha );
const b = useContext(Beta123)
const c = useContext(_gamma)
"""
# Expect matches in the order they appear, preserving duplicates and order.
codeflash_output = _extract_context_subscriptions(src) # 5.54μs -> 3.33μs (66.6% faster)
def test_no_false_positives_when_prefixed_or_suffixed():
# If useContext appears as part of a larger word it should NOT match (word boundary).
src = "const a = myuseContext(Foo); const b = useContexted(Bar);"
# No valid matches because 'useContext' is not a standalone token in either case.
codeflash_output = _extract_context_subscriptions(src) # 3.35μs -> 2.11μs (58.3% faster)
# Also test when a letter immediately precedes useContext (no word boundary).
src2 = "somethinguseContext(Baz)"
codeflash_output = _extract_context_subscriptions(src2) # 1.15μs -> 611ns (88.5% faster)
def test_member_access_inside_parentheses_captures_only_first_token():
# When the argument is a dotted expression, the regex captures only the first \w+ token.
src = "const x = useContext(MyContext.Consumer);"
# Only "MyContext" should be captured (dot breaks the \w+ match).
codeflash_output = _extract_context_subscriptions(src) # 3.85μs -> 2.09μs (83.7% faster)
# Also when there is an underscore in the identifier it should be captured fully.
src2 = "useContext(My_Context.someMember)"
codeflash_output = _extract_context_subscriptions(src2) # 1.68μs -> 962ns (74.9% faster)
def test_string_literal_argument_is_not_matched():
# If the first character inside the parentheses is a quote, \w+ won't match it.
src = 'const x = useContext("QuotedContext"); const y = useContext(\'Other\');'
# Neither call should produce a match because the argument starts with a quote.
codeflash_output = _extract_context_subscriptions(src) # 3.87μs -> 2.62μs (47.9% faster)
# Mixed case: one quoted and one unquoted - only the unquoted one should match.
src2 = "useContext('Quoted'); useContext(Unquoted);"
codeflash_output = _extract_context_subscriptions(src2) # 2.25μs -> 1.23μs (82.8% faster)
def test_matches_in_comments_but_not_inside_string_literals_without_quotes():
# The regex operates on raw source text; it will match inside comments.
src = "// useContext(CommentContext)\nconst a = useContext(RealContext);\n"
# Both 'CommentContext' and 'RealContext' are plain-word arguments and should be matched.
codeflash_output = _extract_context_subscriptions(src) # 4.61μs -> 2.50μs (84.0% faster)
# If the occurrence is inside a quoted string, the leading quote prevents a match.
src2 = '"useContext(StringContext)"; useContext(Actual);'
# "StringContext" is inside quotes -> no match; Actual should be captured.
codeflash_output = _extract_context_subscriptions(src2) # 1.89μs -> 1.01μs (87.1% faster)
def test_empty_input_returns_empty_list():
# Empty source should produce an empty list.
codeflash_output = _extract_context_subscriptions("") # 1.74μs -> 521ns (235% faster)
def test_large_scale_many_matches_and_order_preservation():
# Build a large source string containing 1000 useContext calls with varying names.
parts = []
expected = []
count = 1000 # reasonably large scalar per instructions
for i in range(count):
# alternate spacing patterns to ensure regex handles whitespace variations
if i % 3 == 0:
parts.append(f"useContext(Ctx{i})")
elif i % 3 == 1:
parts.append(f"useContext ( Ctx{i} )")
else:
parts.append(f"useContext(\tCtx{i})")
expected.append(f"Ctx{i}")
# Join with semicolons and newlines to imitate real JS source.
src = ";\n".join(parts) + ";"
codeflash_output = _extract_context_subscriptions(src); result = codeflash_output # 354μs -> 229μs (54.4% faster)
def test_duplicates_and_consecutive_matches_preserve_order():
# Ensure duplicates are preserved and consecutive matches are all captured.
src = "useContext(A);useContext(A); useContext(B);useContext(A)"
# The function should return all matches in appearance order, including duplicates.
codeflash_output = _extract_context_subscriptions(src) # 5.08μs -> 2.69μs (89.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.import pytest
from codeflash.languages.javascript.frameworks.react.context import \
_extract_context_subscriptions
class TestExtractContextSubscriptionsBasic:
"""Basic tests verify fundamental functionality with typical inputs."""
def test_single_context_subscription(self):
"""Test extraction of a single useContext call."""
source = "const theme = useContext(ThemeContext);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.85μs -> 2.06μs (86.5% faster)
def test_multiple_context_subscriptions(self):
"""Test extraction of multiple useContext calls in same component."""
source = """
const theme = useContext(ThemeContext);
const user = useContext(UserContext);
const settings = useContext(SettingsContext);
"""
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 5.68μs -> 3.55μs (60.1% faster)
def test_context_with_whitespace_variations(self):
"""Test that various whitespace patterns are handled correctly."""
source = "useContext(MyContext)"
codeflash_output = _extract_context_subscriptions(source); result1 = codeflash_output # 3.35μs -> 1.71μs (95.4% faster)
source_with_spaces = "useContext ( MyContext )"
codeflash_output = _extract_context_subscriptions(source_with_spaces); result2 = codeflash_output # 1.40μs -> 781ns (79.6% faster)
source_with_newline = "useContext(\nMyContext\n)"
codeflash_output = _extract_context_subscriptions(source_with_newline); result3 = codeflash_output # 1.02μs -> 501ns (104% faster)
def test_context_in_function_body(self):
"""Test extraction from within a function definition."""
source = """
function MyComponent() {
const context = useContext(AppContext);
return <div>{context.value}</div>;
}
"""
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 5.39μs -> 3.60μs (49.8% faster)
def test_context_in_jsx_component(self):
"""Test extraction from a JSX component."""
source = """
export const MyComponent = () => {
const darkMode = useContext(ThemeContext);
return <div>Theme: {darkMode}</div>;
};
"""
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 5.47μs -> 3.65μs (50.0% faster)
class TestExtractContextSubscriptionsEdge:
"""Edge tests evaluate behavior under extreme or unusual conditions."""
def test_empty_string(self):
"""Test with empty source code string."""
source = ""
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 1.63μs -> 581ns (181% faster)
def test_no_context_subscriptions(self):
"""Test source with no useContext calls."""
source = "const x = useState(0); const y = useReducer(reducer, init);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.27μs -> 1.91μs (70.8% faster)
def test_context_name_with_underscores(self):
"""Test context names containing underscores."""
source = "const ctx = useContext(Theme_Context_Name);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.01μs -> 2.23μs (79.4% faster)
def test_context_name_with_numbers(self):
"""Test context names containing numbers."""
source = "const ctx = useContext(Context123);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.79μs -> 2.06μs (83.5% faster)
def test_context_starting_with_number(self):
"""Test that context names starting with numbers are NOT matched (invalid JS identifier)."""
source = "const ctx = useContext(123Context);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.67μs -> 2.00μs (82.9% faster)
def test_usecontext_as_part_of_word(self):
"""Test that useContext only matches as a word boundary."""
source = "myuseContext(MyContext); useContext(RealContext);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.94μs -> 2.19μs (79.4% faster)
def test_nested_usecontext_calls(self):
"""Test multiple useContext calls on same line."""
source = "const a = useContext(A), b = useContext(B), c = useContext(C);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.84μs -> 2.77μs (75.0% faster)
def test_usecontext_with_no_argument(self):
"""Test useContext with empty parentheses (malformed code)."""
source = "useContext();"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 2.92μs -> 1.57μs (85.3% faster)
def test_usecontext_with_non_identifier_argument(self):
"""Test useContext called with non-identifier argument (e.g., string literal)."""
source = 'const ctx = useContext("ThemeContext");'
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.32μs -> 1.96μs (68.9% faster)
def test_usecontext_with_variable_argument(self):
"""Test useContext with variable as argument (still an identifier)."""
source = "const MyContext = createContext(); const ctx = useContext(MyContext);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.18μs -> 2.52μs (66.1% faster)
def test_usecontext_case_sensitive(self):
"""Test that useContext matching is case-sensitive."""
source = "const x = UseContext(MyContext); const y = useContext(RealContext);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.22μs -> 2.42μs (73.9% faster)
def test_comment_containing_usecontext(self):
"""Test that useContext in comments is still extracted (regex doesn't parse comments)."""
source = "// const x = useContext(CommentContext);\nconst y = useContext(RealContext);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.54μs -> 2.75μs (64.8% faster)
def test_string_containing_usecontext(self):
"""Test that useContext in string literals is still extracted (regex doesn't parse strings)."""
source = 'const msg = "useContext(StringContext)"; const ctx = useContext(RealContext);'
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.59μs -> 2.67μs (72.2% faster)
def test_duplicate_context_subscriptions(self):
"""Test that duplicate useContext calls are both extracted."""
source = """
const theme1 = useContext(ThemeContext);
const theme2 = useContext(ThemeContext);
"""
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.88μs -> 2.85μs (70.9% faster)
def test_single_letter_context_name(self):
"""Test context with single letter name."""
source = "const x = useContext(A);"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.67μs -> 1.95μs (87.8% faster)
def test_very_long_context_name(self):
"""Test context with very long name."""
long_name = "A" * 100
source = f"const x = useContext({long_name});"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.88μs -> 2.18μs (77.6% faster)
def test_tabs_instead_of_spaces(self):
"""Test useContext with tabs as whitespace."""
source = "useContext\t(\tMyContext\t)"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.35μs -> 1.80μs (85.6% faster)
def test_mixed_whitespace(self):
"""Test useContext with mixed tabs and spaces."""
source = "useContext \t ( \t MyContext \t )"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.56μs -> 1.77μs (101% faster)
def test_multiline_with_carriage_returns(self):
"""Test source with various line ending formats."""
source = "useContext(ContextA)\r\nuseContext(ContextB)"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 4.14μs -> 2.27μs (82.0% faster)
class TestExtractContextSubscriptionsLargeScale:
"""Large-scale tests assess performance and scalability."""
def test_hundred_context_subscriptions(self):
"""Test extraction with 100 useContext calls."""
# Build source with 100 different context subscriptions
lines = [f"const ctx{i} = useContext(Context{i});" for i in range(100)]
source = "\n".join(lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 48.8μs -> 35.0μs (39.6% faster)
def test_thousand_context_subscriptions(self):
"""Test extraction with 1000 useContext calls."""
# Build source with 1000 different context subscriptions
lines = [f"const ctx{i} = useContext(Ctx{i});" for i in range(1000)]
source = "\n".join(lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 475μs -> 353μs (34.3% faster)
def test_deeply_nested_component_tree(self):
"""Test extraction from source with deeply nested component definitions."""
source = ""
for depth in range(100):
source += f"function Component{depth}() {{\n"
source += f" const ctx = useContext(Context{depth});\n"
for depth in range(100):
source += "}\n"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 74.3μs -> 59.6μs (24.7% faster)
def test_large_source_file_with_many_other_hooks(self):
"""Test extraction from realistic large source file with many hooks."""
source_lines = []
expected_contexts = []
for i in range(500):
source_lines.append(f"const state{i} = useState(null);")
if i % 3 == 0: # Add useContext every third line
source_lines.append(f"const ctx{i} = useContext(Ctx{i});")
expected_contexts.append(f"Ctx{i}")
source_lines.append(f"const effect{i} = useEffect(() => {{}}, []);")
source = "\n".join(source_lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 467μs -> 439μs (6.30% faster)
def test_very_long_source_line(self):
"""Test extraction from extremely long single line."""
# Create a very long line with multiple useContext calls
source = " ".join([f"useContext(Ctx{i})" for i in range(500)])
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 152μs -> 91.9μs (66.2% faster)
def test_many_whitespace_variations(self):
"""Test extraction from source with many different whitespace patterns."""
source_lines = []
expected_contexts = []
patterns = [
("useContext({})", "Ctx{}"),
("useContext ({})", "Ctx{}"),
("useContext ( {} )", "Ctx{}"),
("useContext\n({})", "Ctx{}"),
("useContext(\n{})", "Ctx{}"),
]
for i in range(200):
pattern_idx = i % len(patterns)
pattern, context_pattern = patterns[pattern_idx]
context_name = f"Context{i}"
source_lines.append(pattern.format(context_name))
expected_contexts.append(context_name)
source = "\n".join(source_lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 68.6μs -> 44.0μs (55.9% faster)
def test_alternating_matching_and_non_matching(self):
"""Test extraction alternating between matching and non-matching patterns."""
source_lines = []
expected_contexts = []
for i in range(500):
if i % 2 == 0:
# Matching pattern
source_lines.append(f"const x = useContext(ValidCtx{i});")
expected_contexts.append(f"ValidCtx{i}")
else:
# Non-matching patterns
source_lines.append(f"const y = useState(null);")
source_lines.append(f"const z = myuseContext(FakeCtx{i});")
source = "\n".join(source_lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 267μs -> 234μs (13.8% faster)
def test_performance_with_regex_backtracking(self):
"""Test extraction doesn't suffer from catastrophic regex backtracking."""
# Create source that could cause backtracking with poorly designed regex
# Lots of parentheses but only some are part of useContext calls
source = "(((useContext(TestContext)))))"
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 3.76μs -> 1.96μs (91.3% faster)
def test_many_contexts_with_similar_names(self):
"""Test extraction distinguishes between contexts with similar names."""
source_lines = [
"useContext(Context)",
"useContext(Context1)",
"useContext(Context2)",
"useContext(Context_A)",
"useContext(ContextA)",
"useContext(AContext)",
]
source = "\n".join(source_lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 5.69μs -> 3.21μs (77.5% faster)
def test_stress_test_unicode_boundary(self):
"""Test that regex works with various identifier patterns at scale."""
# \w includes unicode word characters, test we handle them
source_lines = []
expected = []
for i in range(100):
# Standard ASCII identifiers
source_lines.append(f"useContext(AsciiContext{i});")
expected.append(f"AsciiContext{i}")
source = "\n".join(source_lines)
codeflash_output = _extract_context_subscriptions(source); result = codeflash_output # 37.4μs -> 23.3μs (60.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T04.29.42
Suggested change
| return [match.group(1) for match in _CONTEXT_RE.finditer(component_source)] | |
| return _CONTEXT_RE.findall(component_source) |
Contributor
⚡️ Codeflash found optimizations for this PR📄 27% (0.27x) speedup for
|
Contributor
⚡️ Codeflash found optimizations for this PR📄 685% (6.85x) speedup for
|
Comment on lines
+203
to
+209
| hooks = [] | ||
| seen = set() | ||
| for match in HOOK_EXTRACT_RE.finditer(function_source): | ||
| hook_name = match.group(1) | ||
| if hook_name not in seen: | ||
| seen.add(hook_name) | ||
| hooks.append(hook_name) |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 54% (0.54x) speedup for _extract_hooks_used in codeflash/languages/javascript/frameworks/react/discovery.py
⏱️ Runtime : 3.62 milliseconds → 2.35 milliseconds (best of 110 runs)
📝 Explanation and details
I replaced the Python-level iteration and explicit set bookkeeping with a fast, C-level pipeline: re.findall to get all captured hook names and dict.fromkeys to remove duplicates while preserving first-seen order. This avoids Python loop overhead and repeated attribute lookups, resulting in lower CPU and memory overhead for typical inputs.✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 66 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
from codeflash.languages.javascript.frameworks.react.discovery import \
_extract_hooks_used
def test_basic_extract_order_and_uniqueness():
# A small snippet with two different hooks and a repeated one later.
src = """
function Component() {
const [state, setState] = useState(0); // first occurrence of useState
useEffect(() => { /* effect */ }, []);
// later the same hook appears again
const another = useState(1);
return null;
}
"""
# Expect the first appearance order preserved, and duplicate removed.
codeflash_output = _extract_hooks_used(src) # 11.4μs -> 10.1μs (13.1% faster)
def test_supports_generics_and_spaces_and_newlines():
# Hooks with TypeScript-style generics and extra whitespace/newlines should be recognized.
src = """
const ref = useRef<HTMLDivElement>(null);
const val = useMemo <number> ( () => 42 );
// also ensure a normal hook appears
useCallback(() => {}, []);
"""
# The extractor should return the hook names in the order they first appear.
codeflash_output = _extract_hooks_used(src) # 8.24μs -> 6.79μs (21.4% faster)
def test_empty_string_and_lowercase_no_match():
# Empty input should yield an empty list.
codeflash_output = _extract_hooks_used("") # 1.81μs -> 681ns (166% faster)
# 'useeffect' with a lowercase 'e' should not match because regex expects an uppercase letter after 'use'.
codeflash_output = _extract_hooks_used("useeffect()") # 1.71μs -> 1.23μs (38.9% faster)
# A similar-looking identifier with characters before 'use' should not match because of the word boundary.
codeflash_output = _extract_hooks_used("myuseState()") # 912ns -> 541ns (68.6% faster)
def test_matches_inside_strings_and_comments():
# The regex does not attempt to parse JS strings/comments specially, so occurrences inside them are matched too.
src = '''
// a comment containing useDebugValue()
const s = "a string mentioning useCustom() and even useOther()";
/* block comment useLayoutEffect() */
// actual code call
useReal();
'''
# The expected order is the textual appearance order of the matches.
# First matched in the file: useDebugValue (comment), then useCustom (string),
# then useOther (string), then useLayoutEffect (block comment), then useReal (code).
codeflash_output = _extract_hooks_used(src) # 9.32μs -> 7.18μs (29.7% faster)
def test_non_string_input_raises_type_error():
# Passing None (or other non-string) should raise a TypeError when the regex tries to iterate.
with pytest.raises(TypeError):
_extract_hooks_used(None) # 3.32μs -> 2.92μs (13.8% faster)
def test_word_boundary_prevents_prefix_matches_but_allows_suffixes():
# 'myuseX' should not match because 'use' is not at a word boundary.
codeflash_output = _extract_hooks_used("myuseState() useState()") # 4.72μs -> 3.83μs (23.3% faster)
# A hook name can have suffixes (e.g. useStateHook) and still match because it begins with 'use' + Capital letter.
codeflash_output = _extract_hooks_used("useStateHook()") # 1.85μs -> 1.49μs (24.1% faster)
def test_large_scale_unique_hooks_1000():
# Generate 1000 unique hook calls in order: useHook0(), useHook1(), ..., useHook999()
parts = [f"useHook{i}()" for i in range(1000)]
src = ";\n".join(parts) + ";"
codeflash_output = _extract_hooks_used(src); result = codeflash_output # 488μs -> 297μs (64.2% faster)
# assert full equality to the expected list
expected = [f"useHook{i}" for i in range(1000)]
def test_large_scale_repeated_hooks_many_times():
# Create a large source with only 10 unique hooks repeated many times.
unique = [f"useX{i}" for i in range(10)]
# Repeat the sequence 100 times to create 1000 occurrences total.
occurrences = unique * 100
src = " ".join(f"{name}()" for name in occurrences)
codeflash_output = _extract_hooks_used(src); result = codeflash_output # 384μs -> 229μs (67.3% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.from __future__ import annotations
import re
# imports
import pytest
from codeflash.languages.javascript.frameworks.react.discovery import \
_extract_hooks_used
class TestExtractHooksUsedBasic:
"""Basic tests for normal, expected usage patterns."""
def test_single_hook_basic(self):
"""Test extraction of a single basic hook call."""
source = "useState()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.01μs -> 3.25μs (23.4% faster)
def test_multiple_hooks_in_sequence(self):
"""Test extraction of multiple hooks called in sequence."""
source = "useState() useEffect() useContext()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.93μs -> 4.45μs (33.3% faster)
def test_hook_with_whitespace_before_paren(self):
"""Test hook with spaces before opening parenthesis."""
source = "useState ()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.06μs -> 3.21μs (26.6% faster)
def test_hook_with_generic_type_parameter(self):
"""Test hook with generic type parameter (TypeScript syntax)."""
source = "useState<number>()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.13μs -> 3.32μs (24.5% faster)
def test_hook_with_complex_generic_type(self):
"""Test hook with complex generic type containing nested angle brackets."""
source = "useState<Record<string, number>>()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.38μs -> 3.19μs (37.0% faster)
def test_hook_with_whitespace_around_generics(self):
"""Test hook with whitespace around generic type parameter."""
source = "useState < string > ()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.29μs -> 3.44μs (24.8% faster)
def test_hook_with_arguments(self):
"""Test hook extraction ignores the arguments inside parentheses."""
source = "useState(initialValue)"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.52μs -> 3.50μs (29.3% faster)
def test_hook_with_complex_arguments(self):
"""Test hook with complex function arguments."""
source = "useEffect(() => { console.log('effect'); }, [deps])"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.93μs -> 4.01μs (23.0% faster)
def test_custom_hook_extraction(self):
"""Test extraction of custom hooks (user-defined hooks)."""
source = "useCustomHook() useAnotherHook()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.14μs -> 4.03μs (27.6% faster)
def test_hook_in_function_body(self):
"""Test hook extraction from within a function body."""
source = "function MyComponent() { useState(); useEffect(); }"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.43μs -> 4.26μs (27.5% faster)
def test_hook_preserves_order(self):
"""Test that hooks are returned in order of first appearance."""
source = "useState() useContext() useEffect()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.53μs -> 4.31μs (28.4% faster)
def test_hook_with_lowercase_after_use(self):
"""Test that hooks must have uppercase letter immediately after 'use'."""
source = "useState() userfunc() useRef()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.34μs -> 4.06μs (31.6% faster)
def test_hook_name_boundary_word_boundary(self):
"""Test that hook names must start at word boundary."""
source = "myuseState() useState()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.32μs -> 3.51μs (23.1% faster)
def test_use_prefix_alone_not_matched(self):
"""Test that 'use' alone without uppercase letter after is not matched."""
source = "use() usea() useA()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.39μs -> 3.57μs (23.0% faster)
class TestExtractHooksUsedEdgeCases:
"""Edge case tests for boundary values and unusual conditions."""
def test_empty_string(self):
"""Test extraction from empty string."""
source = ""
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 1.70μs -> 742ns (130% faster)
def test_no_hooks_in_source(self):
"""Test source with no hook calls."""
source = "const x = 5; const y = 10;"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 2.98μs -> 1.82μs (63.2% faster)
def test_duplicate_hooks_deduplicated(self):
"""Test that duplicate hooks are not included multiple times."""
source = "useState() useState() useState()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.96μs -> 4.58μs (30.2% faster)
def test_duplicate_hooks_interleaved(self):
"""Test deduplication with interleaved duplicate hooks."""
source = "useState() useEffect() useState() useContext() useEffect()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 6.97μs -> 5.20μs (34.1% faster)
def test_hook_with_newlines(self):
"""Test hook extraction with newlines in source."""
source = "useState()\nuseEffect()\nuseContext()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.64μs -> 4.27μs (32.1% faster)
def test_hook_with_tabs(self):
"""Test hook extraction with tabs in source."""
source = "useState()\t useEffect()\t useContext()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.58μs -> 4.28μs (30.4% faster)
def test_hook_with_multiline_generic(self):
"""Test hook with generic type spanning multiple lines."""
source = "useState<\n string\n>()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.23μs -> 3.35μs (26.4% faster)
def test_hook_immediately_followed_by_other_text(self):
"""Test hook immediately followed by other identifiers."""
source = "useState()otherFunction()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.45μs -> 3.62μs (23.0% faster)
def test_hook_in_comment_is_not_extracted(self):
"""Test that hooks in comments are still extracted (regex doesn't parse comments)."""
# Note: The function does NOT handle comments specially, it just looks for patterns
source = "// useState() \nuseEffect()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.16μs -> 4.00μs (29.1% faster)
def test_hook_in_string_is_extracted(self):
"""Test that hooks in strings are extracted (regex doesn't parse strings)."""
# Note: The function does NOT handle strings specially
source = 'const str = "useState()"; useEffect();'
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.17μs -> 4.11μs (25.8% faster)
def test_malformed_hook_no_parenthesis(self):
"""Test that malformed hook calls without parenthesis are not matched."""
source = "useState useEffect() useContext()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 6.07μs -> 4.68μs (29.7% faster)
def test_hook_with_very_long_name(self):
"""Test hook with a very long name."""
long_hook_name = "use" + "A" * 100 + "Hook"
source = f"{long_hook_name}()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.34μs -> 3.56μs (22.0% faster)
def test_hook_with_numbers_in_name(self):
"""Test hook with numbers in the name."""
source = "useEffect2() useCustom123Hook() useState1()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.78μs -> 4.42μs (30.9% faster)
def test_hook_name_with_underscores(self):
"""Test hook names with underscores."""
source = "use_Effect() use_custom_hook()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 3.08μs -> 2.03μs (51.2% faster)
def test_single_character_after_use(self):
"""Test hook with single character after 'use'."""
source = "useA() useB() useZ()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.63μs -> 4.33μs (30.1% faster)
def test_hook_followed_by_semicolon(self):
"""Test hook call followed by semicolon."""
source = "useState(); useEffect();"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.05μs -> 3.90μs (29.6% faster)
def test_hook_in_jsx_attribute(self):
"""Test hook-like pattern in JSX (though unusual)."""
source = "<Component useHook={true} />"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 3.74μs -> 2.77μs (35.2% faster)
def test_use_followed_by_whitespace_and_uppercase(self):
"""Test 'use' followed by whitespace then uppercase (should not match due to regex)."""
source = "use Effect()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 2.73μs -> 1.66μs (63.9% faster)
def test_nested_hook_calls(self):
"""Test nested hook function calls."""
source = "useState(useRef())"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.20μs -> 4.00μs (30.0% faster)
def test_hook_in_ternary_operator(self):
"""Test hooks in ternary operator."""
source = "condition ? useState() : useEffect()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.21μs -> 4.13μs (26.2% faster)
def test_generic_with_union_type(self):
"""Test generic with union type."""
source = "useState<string | number>()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.23μs -> 3.41μs (24.1% faster)
def test_generic_with_function_type(self):
"""Test generic with function type."""
source = "useState<(x: number) => string>()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 4.40μs -> 3.32μs (32.6% faster)
class TestExtractHooksUsedLargeScale:
"""Large-scale tests for performance and scalability."""
def test_many_unique_hooks(self):
"""Test extraction with many unique hooks."""
# Create 100 unique hook names
hooks = [f"use{chr(65 + (i % 26))}{i}Hook" for i in range(100)]
source = " ".join(f"{hook}()" for hook in hooks)
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 50.0μs -> 32.1μs (55.6% faster)
def test_many_duplicate_hooks(self):
"""Test deduplication with many duplicate hook calls."""
# Create 1000 calls to same hook
source = "useState() " * 1000
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 384μs -> 233μs (64.9% faster)
def test_mixed_unique_and_duplicate_hooks(self):
"""Test with mix of unique hooks repeated multiple times."""
# 10 unique hooks, each repeated 100 times
unique_hooks = [f"useHook{i}" for i in range(10)]
source = " ".join(f"{hook}()" for hook in unique_hooks for _ in range(100))
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 401μs -> 234μs (71.1% faster)
def test_large_source_code(self):
"""Test with large source code containing many hook calls."""
# Create a large source with varied spacing and patterns
lines = []
for i in range(500):
lines.append(f" const hook{i % 10} = use{chr(65 + (i % 10))}Hook();")
source = "\n".join(lines)
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 293μs -> 214μs (36.7% faster)
def test_large_source_with_complex_generics(self):
"""Test large source with complex generic types."""
hooks = []
for i in range(100):
hook_name = f"useHook{i}"
hooks.append(hook_name)
source = ""
for i, hook in enumerate(hooks):
# Create complex generics with nested angle brackets
generic_type = f"<{{'key': string, value: number}}>"
source += f" {hook}{generic_type}()\n"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 56.1μs -> 37.0μs (51.7% faster)
def test_performance_with_many_non_hook_patterns(self):
"""Test performance when source has many non-hook patterns."""
# Mix of hook and non-hook patterns
source = ""
for i in range(500):
source += f"const var{i} = value{i}; "
if i % 10 == 0:
source += "useState(); "
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 145μs -> 136μs (6.44% faster)
def test_extremely_long_hook_name(self):
"""Test with extremely long hook name."""
long_name = "use" + "A" * 10000
source = f"{long_name}()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 31.7μs -> 30.7μs (3.13% faster)
def test_source_with_10000_characters(self):
"""Test extraction from large source file (10000+ characters)."""
# Create a realistic large source
source = "function Component() {\n"
for i in range(500):
source += f" useState{i % 5}(); useEffect{i % 3}(); useContext{i % 7}();\n"
source += "}"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 637μs -> 411μs (55.1% faster)
def test_many_sequential_duplicates(self):
"""Test deduplication of many sequential duplicate calls."""
# 1000 sequential calls to useState
source = "".join(["useState() " for _ in range(1000)])
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 399μs -> 233μs (70.7% faster)
def test_return_type_consistency(self):
"""Test that return type is always a list."""
test_cases = [
"",
"useState()",
"useState() useEffect() useContext()",
"useState() " * 100,
]
for source in test_cases:
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 47.6μs -> 30.9μs (54.1% faster)
def test_order_preservation_with_many_hooks(self):
"""Test that order is preserved with many different hooks."""
hook_names = [f"useHook{i}" for i in range(100)]
source = " ".join(f"{hook}()" for hook in hook_names)
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 50.7μs -> 31.4μs (61.6% faster)
def test_edge_case_last_hook_is_duplicate(self):
"""Test when last hook in source is a duplicate of earlier hook."""
source = "useState() useEffect() useState()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.78μs -> 4.28μs (35.1% faster)
def test_all_same_hook_repeated_with_gaps(self):
"""Test repeated same hook with various patterns between."""
source = "useState() console.log('test'); useState() if(x) useState()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 6.15μs -> 4.85μs (26.9% faster)
def test_hooks_with_all_uppercase_letters(self):
"""Test extraction of hooks with multiple uppercase letters."""
source = "useABCDEF() useXYZ() useHTMLElement()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 5.75μs -> 4.36μs (32.0% faster)
def test_mixed_standard_and_custom_hooks(self):
"""Test mix of React standard hooks and custom hooks."""
source = """
useState()
useEffect()
useContext()
useReducer()
useCallback()
useMemo()
useRef()
useImperativeHandle()
useLayoutEffect()
useDebugValue()
useCustom()
useMyHook()
"""
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 11.9μs -> 8.84μs (35.0% faster)
def test_return_order_matches_first_occurrence_order(self):
"""Verify that order in result matches first occurrence in source."""
source = "useD() useC() useB() useA() useD() useC()"
codeflash_output = _extract_hooks_used(source); result = codeflash_output # 7.01μs -> 5.17μs (35.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T05.32.06
Suggested change
| hooks = [] | |
| seen = set() | |
| for match in HOOK_EXTRACT_RE.finditer(function_source): | |
| hook_name = match.group(1) | |
| if hook_name not in seen: | |
| seen.add(hook_name) | |
| hooks.append(hook_name) | |
| matches = HOOK_EXTRACT_RE.findall(function_source) | |
| if not matches: | |
| return [] | |
| # Use dict.fromkeys to preserve first-seen order while removing duplicates. | |
| hooks = list(dict.fromkeys(matches)) |
Comment on lines
+24
to
+31
| logger = logging.getLogger(__name__) | ||
|
|
||
| MARKER_PREFIX = "REACT_RENDER" | ||
|
|
||
|
|
||
| def generate_render_counter_code(component_name: str) -> str: | ||
| """Generate the onRender callback and counter variable for Profiler instrumentation.""" | ||
| safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", component_name) |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 31% (0.31x) speedup for generate_render_counter_code in codeflash/languages/javascript/frameworks/react/profiler.py
⏱️ Runtime : 1.50 milliseconds → 1.14 milliseconds (best of 250 runs)
📝 Explanation and details
The optimization achieves a 31% runtime improvement (from 1.50ms to 1.14ms) by pre-compiling the regular expression pattern at module load time instead of recompiling it on every function call.
Key Change:
- Before:
re.sub(r"[^a-zA-Z0-9_]", "_", component_name)compiled the regex pattern on every call - After:
_SAFE_NAME_RE = re.compile(r"[^a-zA-Z0-9_]")compiles once at module import, then_SAFE_NAME_RE.sub("_", component_name)reuses the compiled pattern
Why This Is Faster:
Regular expression compilation in Python involves parsing the pattern string, building an internal state machine, and allocating data structures. This overhead occurs every time re.sub() is called with a raw pattern string. By compiling once at module load, we pay this cost only once and reuse the compiled regex object for all subsequent calls. The line profiler shows the sanitization line dropped from 3.17ms (64% of runtime) to 1.33ms (42% of runtime) - a 58% reduction in that hotspot.
Impact on Workloads:
Based on the function references, generate_render_counter_code() is called from test utilities that instrument React components for profiling. The annotated tests show this function being called:
- With various component names in tight loops (test_large_scale_many_names_and_safety_checks: 1000 iterations showing 30% speedup)
- Repeatedly with the same name (test_large_scale_consistency_and_repeatability: 50 calls showing 43% speedup)
- In batch processing (test_generate_code_for_many_components: 100 components)
Since React applications can have hundreds of components that need instrumentation, and developers may regenerate profiling code frequently during development cycles, this optimization provides meaningful wall-clock time savings when processing many components.
Test Case Performance:
The optimization shows consistent improvements across all test cases:
- Simple names: 62-78% faster (e.g., "Button", "App")
- Names with special characters: 37-51% faster (benefits most from cached regex)
- Empty/single character names: 72-99% faster
- Very long names (500 chars): 22% faster
- Batch operations: 30-49% faster
The optimization is particularly effective for names requiring more substitutions (special characters), as the compiled regex avoids repeated pattern parsing overhead while performing the same character replacements.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 1094 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import re # used to validate the safe name transformation and pattern matching
import pytest # used for our unit tests
# import the function and constant from the real module under test
from codeflash.languages.javascript.frameworks.react.profiler import (
MARKER_PREFIX, generate_render_counter_code)
def test_basic_functionality_simple_name():
# Use a simple, typical component name
name = "Button"
# Call the function under test
codeflash_output = generate_render_counter_code(name); code = codeflash_output # 3.00μs -> 1.74μs (71.8% faster)
def test_basic_functionality_special_characters_name():
# Component name with spaces and punctuation should be sanitized
name = "My-Component v2.0!"
codeflash_output = generate_render_counter_code(name); code = codeflash_output # 4.42μs -> 3.24μs (36.6% faster)
# The unsafe characters should be replaced with underscores in the safe name
# Based on the implementation, the safe name becomes: My_Component_v2_0_
expected_safe = "My_Component_v2_0_"
# Ensure there are no remaining forbidden characters in the identifier portion
# Extract the identifier from the declaration line and validate characters
decl_line = code.splitlines()[0]
found = re.search(r"let\s+(_codeflash_render_count_[A-Za-z0-9_]*)\s*=", decl_line)
identifier = found.group(1)
def test_basic_functionality_empty_name():
# Edge case: empty component name string
name = ""
codeflash_output = generate_render_counter_code(name); code = codeflash_output # 2.37μs -> 1.26μs (88.0% faster)
def test_edge_numeric_name_and_identifier_appearance():
# Names that are numeric-only are permitted by this generator even if invalid as JS identifiers.
name = "123"
codeflash_output = generate_render_counter_code(name); code = codeflash_output # 2.67μs -> 1.54μs (72.7% faster)
def test_edge_none_raises_type_error():
# Passing None should raise a TypeError because re.sub expects a string
with pytest.raises(TypeError):
generate_render_counter_code(None) # 5.02μs -> 3.49μs (44.0% faster)
def test_edge_preserves_marker_prefix_constant():
# Ensure the generated console log uses the MARKER_PREFIX constant value exactly once in the marker string
name = "Alert"
codeflash_output = generate_render_counter_code(name); code = codeflash_output # 2.69μs -> 1.58μs (69.6% faster)
# There should be exactly one occurrence of the marker prefix within the generated code
occurrences = code.count(MARKER_PREFIX)
def test_large_scale_many_names_and_safety_checks():
# Generate a large number of distinct component names to test scalability and sanitization
N = 1000 # up to 1000 iterations as required
outputs = []
safe_names = set()
# Create deterministic varied names (no randomness) with different characters
for i in range(N):
# Alternate patterns to include digits, hyphens, periods, spaces and underscores
name = f"Comp-{i}.v{i%10} name_{i%5}"
codeflash_output = generate_render_counter_code(name); code = codeflash_output # 1.29ms -> 994μs (30.1% faster)
outputs.append(code)
# Extract declared safe name from the declaration line
decl = code.splitlines()[0]
m = re.search(r"let\s+_codeflash_render_count_([A-Za-z0-9_]*)\s*=", decl)
safe = m.group(1)
safe_names.add(safe)
def test_large_scale_consistency_and_repeatability():
# Calling the function multiple times with the same name should produce identical output each time
name = "Repeater-Case"
codeflash_output = generate_render_counter_code(name); first = codeflash_output # 4.13μs -> 2.90μs (42.1% faster)
for _ in range(50): # repeated calls to check determinism (well below performance threshold)
codeflash_output = generate_render_counter_code(name) # 54.1μs -> 37.8μs (43.0% faster)
# Confirm stable sanitization across calls
safe = re.sub(r"[^a-zA-Z0-9_]", "_", name)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.import re
# imports
import pytest
from codeflash.languages.javascript.frameworks.react.profiler import (
MARKER_PREFIX, generate_render_counter_code)
def test_basic_component_name():
"""Test that a simple component name generates valid JavaScript code."""
codeflash_output = generate_render_counter_code("Button"); result = codeflash_output # 2.89μs -> 1.78μs (61.9% faster)
def test_generated_code_contains_marker_prefix():
"""Test that the generated code includes the MARKER_PREFIX constant."""
codeflash_output = generate_render_counter_code("TestComponent"); result = codeflash_output # 2.86μs -> 1.60μs (78.2% faster)
def test_generated_code_structure():
"""Test that generated code has the expected structure with counter and function."""
codeflash_output = generate_render_counter_code("MyComponent"); result = codeflash_output # 2.75μs -> 1.57μs (74.5% faster)
def test_counter_increment_in_function():
"""Test that the counter is incremented in the onRender callback."""
codeflash_output = generate_render_counter_code("Counter"); result = codeflash_output # 2.77μs -> 1.57μs (75.8% faster)
def test_console_log_with_placeholder_values():
"""Test that the console.log contains template literals for all parameters."""
codeflash_output = generate_render_counter_code("App"); result = codeflash_output # 2.73μs -> 1.55μs (75.5% faster)
def test_component_name_with_underscores():
"""Test that component names with underscores are preserved."""
codeflash_output = generate_render_counter_code("My_Component"); result = codeflash_output # 2.65μs -> 1.57μs (68.8% faster)
def test_component_name_with_numbers():
"""Test that component names with numbers are preserved."""
codeflash_output = generate_render_counter_code("Component123"); result = codeflash_output # 2.58μs -> 1.54μs (66.9% faster)
def test_component_name_with_special_characters():
"""Test that special characters in component names are replaced with underscores."""
codeflash_output = generate_render_counter_code("My-Component@App"); result = codeflash_output # 4.10μs -> 2.98μs (37.7% faster)
def test_component_name_with_spaces():
"""Test that spaces in component names are replaced with underscores."""
codeflash_output = generate_render_counter_code("My Component"); result = codeflash_output # 3.60μs -> 2.46μs (46.5% faster)
def test_component_name_with_dots():
"""Test that dots in component names are replaced with underscores."""
codeflash_output = generate_render_counter_code("my.component.name"); result = codeflash_output # 3.97μs -> 2.81μs (41.4% faster)
def test_empty_component_name():
"""Test that an empty string component name is handled."""
codeflash_output = generate_render_counter_code(""); result = codeflash_output # 2.39μs -> 1.20μs (99.2% faster)
def test_single_character_component_name():
"""Test that single character component names work."""
codeflash_output = generate_render_counter_code("A"); result = codeflash_output # 2.67μs -> 1.55μs (72.2% faster)
def test_component_name_all_special_characters():
"""Test that a component name with only special characters is converted."""
codeflash_output = generate_render_counter_code("@#$%"); result = codeflash_output # 3.75μs -> 2.62μs (43.3% faster)
def test_component_name_with_mixed_case():
"""Test that mixed case component names are preserved."""
codeflash_output = generate_render_counter_code("MyCompOnEnT"); result = codeflash_output # 2.71μs -> 1.62μs (66.7% faster)
def test_component_name_with_leading_numbers():
"""Test that component names starting with numbers are handled."""
codeflash_output = generate_render_counter_code("123Component"); result = codeflash_output # 2.67μs -> 1.50μs (78.1% faster)
def test_component_name_with_unicode_characters():
"""Test that unicode characters in component names are replaced."""
codeflash_output = generate_render_counter_code("Component™"); result = codeflash_output # 4.26μs -> 2.81μs (51.2% faster)
def test_very_long_component_name():
"""Test that very long component names are handled correctly."""
long_name = "A" * 500
codeflash_output = generate_render_counter_code(long_name); result = codeflash_output # 5.73μs -> 4.70μs (21.9% faster)
def test_component_name_with_consecutive_special_characters():
"""Test that consecutive special characters are all replaced."""
codeflash_output = generate_render_counter_code("My###Component"); result = codeflash_output # 4.01μs -> 2.95μs (36.0% faster)
def test_generate_code_for_many_components():
"""Test that the function works correctly when called many times."""
component_names = [f"Component{i}" for i in range(100)]
results = [generate_render_counter_code(name) for name in component_names]
# Each result should contain the correct component identifier
for i, result in enumerate(results):
pass
def test_component_name_with_many_special_characters():
"""Test that component names with many special characters are handled."""
# Create a component name with many different special characters
special_name = "A" + "@#$%^&*()" * 50 + "B"
codeflash_output = generate_render_counter_code(special_name); result = codeflash_output # 34.8μs -> 33.5μs (3.98% faster)
def test_generated_code_is_valid_javascript_like():
"""Test that the generated code has the correct JavaScript syntax."""
codeflash_output = generate_render_counter_code("TestComp"); result = codeflash_output # 2.67μs -> 1.56μs (70.5% faster)
def test_marker_prefix_consistency():
"""Test that MARKER_PREFIX is consistently used in output."""
names = ["Comp1", "Comp2", "Comp3"]
results = [generate_render_counter_code(name) for name in names]
# All results should contain the same MARKER_PREFIX
for result in results:
pass
def test_safe_name_replacement_behavior():
"""Test that the regex replacement works as expected for edge case patterns."""
# Test various patterns to ensure regex works correctly
test_cases = [
("a-b", "a_b"),
("a_b", "a_b"),
("a.b", "a_b"),
("a b", "a_b"),
("a@b", "a_b"),
("abc123def", "abc123def"),
("_abc_", "_abc_"),
]
for input_name, expected_safe_part in test_cases:
codeflash_output = generate_render_counter_code(input_name); result = codeflash_output # 9.93μs -> 6.66μs (49.1% faster)
def test_generated_code_contains_all_required_fields():
"""Test that the generated code contains all required fields for Profiler."""
codeflash_output = generate_render_counter_code("ProfiledComponent"); result = codeflash_output # 2.79μs -> 1.66μs (68.1% faster)
def test_output_is_string_type():
"""Test that the function always returns a string."""
test_names = ["", "A", "Component", "My-Component@1.0", "🚀"]
for name in test_names:
codeflash_output = generate_render_counter_code(name); result = codeflash_output # 9.31μs -> 6.21μs (49.8% faster)
def test_function_idempotence():
"""Test that calling the function twice with the same input produces identical output."""
component_name = "IdempotentComponent"
codeflash_output = generate_render_counter_code(component_name); result1 = codeflash_output # 2.73μs -> 1.65μs (64.8% faster)
codeflash_output = generate_render_counter_code(component_name); result2 = codeflash_output # 1.21μs -> 721ns (68.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T05.51.19
Suggested change
| logger = logging.getLogger(__name__) | |
| MARKER_PREFIX = "REACT_RENDER" | |
| def generate_render_counter_code(component_name: str) -> str: | |
| """Generate the onRender callback and counter variable for Profiler instrumentation.""" | |
| safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", component_name) | |
| _SAFE_NAME_RE = re.compile(r"[^a-zA-Z0-9_]") | |
| logger = logging.getLogger(__name__) | |
| MARKER_PREFIX = "REACT_RENDER" | |
| def generate_render_counter_code(component_name: str) -> str: | |
| """Generate the onRender callback and counter variable for Profiler instrumentation.""" | |
| safe_name = _SAFE_NAME_RE.sub("_", component_name) |
Contributor
⚡️ Codeflash found optimizations for this PR📄 163% (1.63x) speedup for
|
Comment on lines
+102
to
+124
| # Check function declarations | ||
| if root_node.type == "function_declaration": | ||
| name_node = root_node.child_by_field_name("name") | ||
| if name_node: | ||
| name = source_bytes[name_node.start_byte : name_node.end_byte].decode("utf-8") | ||
| if name == component_name: | ||
| return root_node | ||
|
|
||
| # Check variable declarators with arrow functions (const MyComp = () => ...) | ||
| if root_node.type == "variable_declarator": | ||
| name_node = root_node.child_by_field_name("name") | ||
| if name_node: | ||
| name = source_bytes[name_node.start_byte : name_node.end_byte].decode("utf-8") | ||
| if name == component_name: | ||
| return root_node | ||
|
|
||
| # Check export statements | ||
| if root_node.type in ("export_statement", "lexical_declaration", "variable_declaration"): | ||
| for child in root_node.children: | ||
| result = _find_component_function(child, component_name, source_bytes) | ||
| if result: | ||
| return result | ||
|
|
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 13% (0.13x) speedup for _find_component_function in codeflash/languages/javascript/frameworks/react/profiler.py
⏱️ Runtime : 510 microseconds → 453 microseconds (best of 8 runs)
📝 Explanation and details
The optimized code achieves a 12% runtime improvement through two key optimizations:
1. Cache Node Type Access (Primary Optimization)
The original code calls root_node.type up to 3 times per function invocation:
- Once for "function_declaration" check
- Once for "variable_declarator" check
- Once for the tuple membership check ("export_statement", "lexical_declaration", "variable_declaration")
The optimized version caches this in node_type = root_node.type and reuses it. Line profiler data shows this single change saves ~119 nanoseconds per call on the function_declaration path (425086ns → 306274ns for the comparison itself). With 1833 calls, this caching alone provides measurable gains.
2. Eliminate Duplicate Tree Traversal
The original code has a critical flaw: it traverses root_node.children twice for many node types. First for nodes matching ("export_statement", "lexical_declaration", "variable_declaration"), then again in the general case at the bottom. This causes redundant recursive calls.
The optimized version removes the special-case traversal entirely, using a single unified child traversal loop. This is visible in the line profiler where the final for child in root_node.children loop now handles 2959 hits (original: 2801) but makes fewer total recursive calls overall (1798 vs 1640+158=1798 split across two loops).
Performance Impact by Test Case
- Nested/deep structures: 9-12% faster (tests with
export_statement,deeply_nested_structure,many_siblings_before_match) - these benefit most from reduced traversal - Simple matches: Slightly slower (2-10%) for immediate matches where node type caching overhead isn't amortized over recursion
- Overall: The optimization is most effective for realistic React codebases with complex AST structures involving nested declarations and exports
The change from if/if/if to if/elif structure also provides marginal efficiency by short-circuiting unnecessary comparisons once a type match is found.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 33 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
from codeflash.languages.javascript.frameworks.react.profiler import \
_find_component_function
# We must supply real-like Node objects to the function. The original function expects
# objects with attributes/methods matching tree_sitter.Node:
# - .type (str)
# - .children (iterable of child nodes)
# - .child_by_field_name(name) -> Node | None
# - child nodes used as name nodes must expose .start_byte and .end_byte (ints)
#
# We create a minimal concrete helper class that provides these attributes/methods so the
# function can operate as intended. This is necessary to exercise the recursion/lookup
# logic deterministically.
class FakeNode:
def __init__(self, type_, start_byte=0, end_byte=0, children=None, fields=None):
# Node type string (e.g., "function_declaration", "variable_declarator")
self.type = type_
# Byte offsets for name nodes (others can have defaults)
self.start_byte = start_byte
self.end_byte = end_byte
# List of child nodes to iterate over
self.children = list(children) if children else []
# Mapping for child_by_field_name lookups (e.g., {"name": name_node})
self._fields = dict(fields) if fields else {}
def child_by_field_name(self, name):
# Return the child node registered under the given field name, or None.
return self._fields.get(name)
def test_find_function_declaration_by_name():
# Prepare a JS-like source where the function name appears as bytes.
source = b"function MyComp() { return null; }"
# Locate the byte offsets of the name "MyComp".
start = source.find(b"MyComp")
end = start + len(b"MyComp")
# Create a name node that slices the correct bytes from source_bytes.
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
# Create a function_declaration root node with the name field set.
root = FakeNode(type_="function_declaration", children=[], fields={"name": name_node})
# Call the function under test and assert it returns the function_declaration node.
codeflash_output = _find_component_function(root, "MyComp", source); result = codeflash_output # 1.92μs -> 1.96μs (2.09% slower)
def test_function_declaration_name_mismatch_returns_none():
# Source contains a different name than the searched component_name.
source = b"function Other() {}"
start = source.find(b"Other")
end = start + len(b"Other")
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
root = FakeNode(type_="function_declaration", children=[], fields={"name": name_node})
# Searching for a non-existent component name should return None.
codeflash_output = _find_component_function(root, "MyComp", source); result = codeflash_output # 1.99μs -> 1.73μs (14.9% faster)
def test_find_variable_declarator_matches_name():
# Simulate an arrow-function style component assigned via a variable declarator:
source = b"const MyComp = () => {}"
start = source.find(b"MyComp")
end = start + len(b"MyComp")
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
# variable_declarator type should be recognized by the function
root = FakeNode(type_="variable_declarator", children=[], fields={"name": name_node})
codeflash_output = _find_component_function(root, "MyComp", source); result = codeflash_output # 1.36μs -> 1.52μs (10.5% slower)
def test_export_statement_nested_declarator_found():
# Build nested tree: export_statement -> variable_declaration -> variable_declarator(name)
source = b"export const MyComp = () => {}"
start = source.find(b"MyComp")
end = start + len(b"MyComp")
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
var_decl = FakeNode(type_="variable_declarator", children=[], fields={"name": name_node})
var_declaration_container = FakeNode(type_="variable_declaration", children=[var_decl])
export_root = FakeNode(type_="export_statement", children=[var_declaration_container])
# Should find the variable_declarator and return it.
codeflash_output = _find_component_function(export_root, "MyComp", source); result = codeflash_output # 2.52μs -> 2.31μs (9.11% faster)
def test_missing_name_field_does_not_crash_and_returns_none():
# variable_declarator but without a 'name' field; should gracefully return None.
source = b"const = () => {}"
# variable_declarator with no name field (fields omitted)
root = FakeNode(type_="variable_declarator", children=[], fields={})
codeflash_output = _find_component_function(root, "Anything", source); result = codeflash_output # 1.13μs -> 1.06μs (6.59% faster)
def test_nested_children_search_skips_irrelevant_nodes():
# Root has unrelated child types; ensure deep traversal still finds the name when present.
# Build: root -> childA -> childB -> variable_declarator(name)
source = b"// comment\nconst DeepComp = 1;"
start = source.find(b"DeepComp")
end = start + len(b"DeepComp")
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
deep_var = FakeNode(type_="variable_declarator", children=[], fields={"name": name_node})
child_b = FakeNode(type_="some_node", children=[deep_var])
child_a = FakeNode(type_="another_node", children=[child_b])
root = FakeNode(type_="program", children=[child_a])
codeflash_output = _find_component_function(root, "DeepComp", source); result = codeflash_output # 2.69μs -> 2.45μs (9.41% faster)
def test_multibyte_characters_in_name_are_handled_correctly():
# Use a multibyte character in the component name (emoji) to ensure byte slicing uses bytes not characters.
comp_name = "Comp😊" # emoji is multi-byte in UTF-8
# Construct source as UTF-8 encoded bytes
source_str = f"const {comp_name} = () => {{}}"
source = source_str.encode("utf-8")
# Find byte offsets of the name by searching raw bytes of the name encoded as UTF-8
name_bytes = comp_name.encode("utf-8")
start = source.find(name_bytes)
end = start + len(name_bytes)
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
var_decl = FakeNode(type_="variable_declarator", children=[], fields={"name": name_node})
root = FakeNode(type_="program", children=[var_decl])
# Should correctly decode the bytes and match the unicode component name.
codeflash_output = _find_component_function(root, comp_name, source); result = codeflash_output # 2.81μs -> 2.77μs (1.45% faster)
def test_deeply_nested_structure_finds_bottom_node():
# Build a deep nested chain of 1000 nodes, with the matching function at the bottom.
depth = 1000
source = b"function Bottom() {}"
start = source.find(b"Bottom")
end = start + len(b"Bottom")
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
bottom = FakeNode(type_="function_declaration", children=[], fields={"name": name_node})
# Create a chain of container nodes each with a single child leading down to bottom.
current = bottom
for i in range(depth):
current = FakeNode(type_="container", children=[current])
root = current # top-most node
# Searching for "Bottom" should find the bottom node despite deep recursion.
codeflash_output = _find_component_function(root, "Bottom", source); result = codeflash_output
def test_many_siblings_before_match():
# Build a root with 1000 sibling children where only the last sibling contains the matching name.
siblings = []
for i in range(999):
# non-matching variable_declarator with different names
src = f"const X{i} = 0;".encode("utf-8")
name = f"X{i}".encode("utf-8")
start = src.find(name)
end = start + len(name)
name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
siblings.append(FakeNode(type_="variable_declarator", children=[], fields={"name": name_node}))
# The last sibling will have the matching component name
last_source = b"const LastOne = 0;"
last_name_bytes = b"LastOne"
start = last_source.find(last_name_bytes)
end = start + len(last_name_bytes)
last_name_node = FakeNode(type_="identifier", start_byte=start, end_byte=end)
last_sibling = FakeNode(type_="variable_declarator", children=[], fields={"name": last_name_node})
siblings.append(last_sibling)
# Compose a root program node whose children are the siblings; we also provide
# a combined source_bytes that includes all siblings' bytes in sequence so byte offsets
# are valid for nodes derived from their individual sources.
combined_source = b"".join([(f"const X{i} = 0;".encode("utf-8") if i < 999 else last_source) for i in range(1000)])
root = FakeNode(type_="program", children=siblings)
# Searching should return the last_sibling node.
codeflash_output = _find_component_function(root, "LastOne", combined_source); result = codeflash_output # 342μs -> 304μs (12.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T06.09.30
Click to see suggested changes
Suggested change
| # Check function declarations | |
| if root_node.type == "function_declaration": | |
| name_node = root_node.child_by_field_name("name") | |
| if name_node: | |
| name = source_bytes[name_node.start_byte : name_node.end_byte].decode("utf-8") | |
| if name == component_name: | |
| return root_node | |
| # Check variable declarators with arrow functions (const MyComp = () => ...) | |
| if root_node.type == "variable_declarator": | |
| name_node = root_node.child_by_field_name("name") | |
| if name_node: | |
| name = source_bytes[name_node.start_byte : name_node.end_byte].decode("utf-8") | |
| if name == component_name: | |
| return root_node | |
| # Check export statements | |
| if root_node.type in ("export_statement", "lexical_declaration", "variable_declaration"): | |
| for child in root_node.children: | |
| result = _find_component_function(child, component_name, source_bytes) | |
| if result: | |
| return result | |
| node_type = root_node.type | |
| # Check function declarations | |
| if node_type == "function_declaration": | |
| name_node = root_node.child_by_field_name("name") | |
| if name_node: | |
| name = source_bytes[name_node.start_byte : name_node.end_byte].decode("utf-8") | |
| if name == component_name: | |
| return root_node | |
| # Check variable declarators with arrow functions (const MyComp = () => ...) | |
| elif node_type == "variable_declarator": | |
| name_node = root_node.child_by_field_name("name") | |
| if name_node: | |
| name = source_bytes[name_node.start_byte : name_node.end_byte].decode("utf-8") | |
| if name == component_name: | |
| return root_node | |
Comment on lines
+136
to
+157
|
|
||
| def walk(node: Node) -> None: | ||
| # Don't descend into nested functions | ||
| if node != func_node and node.type in ( | ||
| "function_declaration", | ||
| "arrow_function", | ||
| "function", | ||
| "method_definition", | ||
| ): | ||
| return | ||
|
|
||
| if node.type == "return_statement": | ||
| # Check if return value contains JSX | ||
| for child in node.children: | ||
| if _contains_jsx(child): | ||
| returns.append(node) | ||
| break | ||
| else: | ||
| for child in node.children: | ||
| walk(child) | ||
|
|
||
| walk(func_node) |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 17% (0.17x) speedup for _find_jsx_returns in codeflash/languages/javascript/frameworks/react/profiler.py
⏱️ Runtime : 271 microseconds → 232 microseconds (best of 35 runs)
📝 Explanation and details
The optimized code achieves a 16% runtime improvement by eliminating recursive function call overhead through iterative tree traversal.
Key optimization:
The original implementation uses a nested walk() function that recursively traverses the abstract syntax tree. According to the line profiler, 99.3% of the execution time was spent within this recursive function. Python's function call overhead becomes significant when traversing large trees, as each node visit requires a new stack frame.
The optimized version replaces recursion with an explicit stack-based iteration using while stack:. This eliminates the overhead of repeated function calls, stack frame allocation, and context switching. The traversal logic remains identical—children are processed in the same order via reversed(node.children) to maintain depth-first left-to-right traversal.
Additional micro-optimizations:
- Uses
frozensetfor thenested_func_typeslookup, which provides O(1) membership testing with slightly better performance than tuple/list for repeated lookups - Processes nodes directly from the stack without the indirection of recursive calls
Performance characteristics:
The optimization shows its strength on larger inputs. The annotated tests reveal:
- Small trees (5-10 nodes): 21-45% slower due to setup overhead of the stack and frozenset
- Large trees (1000+ nodes): 21% faster, demonstrating the value of eliminating recursive overhead at scale
This makes the optimization particularly valuable when analyzing complex React components with deeply nested JSX structures or large component trees, where the function is likely called in parsing/analysis pipelines that process many nodes.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 7 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
from typing import Any, List
# imports
import pytest # used for our unit tests
# import the module and function under test
from codeflash.languages.javascript.frameworks.react import \
profiler as profiler_module
from codeflash.languages.javascript.frameworks.react.profiler import \
_find_jsx_returns
# helper: a simple real Python class to mimic the minimal Node interface used by the function.
# Note: The function under test only accesses `.type` and `.children` attributes and compares
# nodes by identity (node != func_node). We therefore construct simple nodes that provide
# those attributes. We do not mock or patch tree-sitter; we provide concrete instances
# that behave like tree nodes for the purposes of the algorithm.
class SimpleNode:
def __init__(self, type_: str, children: List["SimpleNode"] | None = None, *, is_jsx: bool = False):
# node type string (e.g., "return_statement", "function_declaration", etc.)
self.type = type_
# children is always a list (the function iterates over node.children)
self.children = list(children) if children else []
# extra flag used by our test _contains_jsx replacement to indicate presence of JSX
self.is_jsx = is_jsx
def __repr__(self) -> str:
# helpful representation for assertion failure messages
return f"SimpleNode(type={self.type!r}, is_jsx={self.is_jsx}, children={len(self.children)})"
def test_single_return_with_jsx(monkeypatch):
# Replace the module's _contains_jsx with a deterministic function that uses our `is_jsx` flag.
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: getattr(node, "is_jsx", False))
# Create a function node that contains a single return_statement whose child is JSX.
jsx_child = SimpleNode("jsx_element", [], is_jsx=True) # a child that should be recognized as JSX
return_node = SimpleNode("return_statement", [jsx_child]) # return statement that returns JSX
func_node = SimpleNode("function_declaration", [return_node]) # top-level function
# Call the function under test.
codeflash_output = _find_jsx_returns(func_node, b""); results = codeflash_output # 3.06μs -> 3.90μs (21.6% slower)
def test_return_without_jsx_is_ignored(monkeypatch):
# _contains_jsx returns False for all nodes here.
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: False)
# Create a function with a return whose child is not JSX.
non_jsx_child = SimpleNode("identifier", [], is_jsx=False)
return_node = SimpleNode("return_statement", [non_jsx_child])
func_node = SimpleNode("function_declaration", [return_node])
# Should not find any JSX returns.
codeflash_output = _find_jsx_returns(func_node, b""); results = codeflash_output # 1.91μs -> 2.83μs (32.5% slower)
def test_nested_function_returns_are_ignored(monkeypatch):
# Configure _contains_jsx to rely on our is_jsx flag.
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: getattr(node, "is_jsx", False))
# Create an inner function that contains a return with JSX (should be ignored).
inner_return = SimpleNode("return_statement", [SimpleNode("jsx_element", [], is_jsx=True)])
inner_function = SimpleNode("function_declaration", [inner_return])
# Create an outer function with its own return with JSX (should be detected).
outer_return = SimpleNode("return_statement", [SimpleNode("jsx_element", [], is_jsx=True)])
outer_function = SimpleNode("function_declaration", [inner_function, outer_return])
# Run detection: only outer_return should be returned.
codeflash_output = _find_jsx_returns(outer_function, b""); results = codeflash_output # 2.42μs -> 3.52μs (31.1% slower)
def test_func_node_can_be_return_statement(monkeypatch):
# If the passed-in func_node itself is a return statement, the algorithm should inspect it.
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: getattr(node, "is_jsx", False))
# The "func_node" is actually a return statement node (odd usage, but the function handles it).
jsx_child = SimpleNode("jsx_element", [], is_jsx=True)
return_node = SimpleNode("return_statement", [jsx_child])
# Passing return_node as func_node directly
codeflash_output = _find_jsx_returns(return_node, b""); results = codeflash_output # 1.43μs -> 1.97μs (27.5% slower)
def test_function_with_no_children_returns_empty(monkeypatch):
# Ensure no accidental exceptions when node.children is empty
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: getattr(node, "is_jsx", False))
empty_func = SimpleNode("function_declaration", [])
codeflash_output = _find_jsx_returns(empty_func, b""); results = codeflash_output # 1.18μs -> 2.16μs (45.4% slower)
def test_multiple_returns_order_and_filtering(monkeypatch):
# Check that multiple return statements are collected in-order and filtered correctly.
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: getattr(node, "is_jsx", False))
# Build several returns with alternating JSX presence.
returns = []
children = []
for i in range(6):
jsx_flag = (i % 2 == 0) # True for even indices
ret = SimpleNode("return_statement", [SimpleNode("child", [], is_jsx=jsx_flag)], is_jsx=False)
# Note: _contains_jsx is called on the child, not the return node itself; we set child's is_jsx.
returns.append(ret)
children.append(ret)
func_node = SimpleNode("function_declaration", children)
codeflash_output = _find_jsx_returns(func_node, b""); results = codeflash_output # 3.76μs -> 5.02μs (25.1% slower)
# Expect the even-indexed return nodes to be present, preserving order
expected = [returns[i] for i in range(6) if i % 2 == 0]
def test_large_scale_many_returns_performance_and_correctness(monkeypatch):
# Make _contains_jsx check the is_jsx flag on children.
monkeypatch.setattr(profiler_module, "_contains_jsx", lambda node: getattr(node, "is_jsx", False))
# Construct a function node with 1000 return children.
total = 1000
children = []
expected = []
for i in range(total):
# Create a child node that will be treated as JSX for even indices.
child = SimpleNode("jsx_element" if (i % 2 == 0) else "identifier", [], is_jsx=(i % 2 == 0))
ret = SimpleNode("return_statement", [child])
children.append(ret)
if i % 2 == 0:
expected.append(ret)
func_node = SimpleNode("function_declaration", children)
# Execute the function under test; this should complete quickly and return the expected nodes.
codeflash_output = _find_jsx_returns(func_node, b""); results = codeflash_output # 256μs -> 212μs (20.9% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T06.13.21
Click to see suggested changes
Suggested change
| def walk(node: Node) -> None: | |
| # Don't descend into nested functions | |
| if node != func_node and node.type in ( | |
| "function_declaration", | |
| "arrow_function", | |
| "function", | |
| "method_definition", | |
| ): | |
| return | |
| if node.type == "return_statement": | |
| # Check if return value contains JSX | |
| for child in node.children: | |
| if _contains_jsx(child): | |
| returns.append(node) | |
| break | |
| else: | |
| for child in node.children: | |
| walk(child) | |
| walk(func_node) | |
| # Use iterative traversal with explicit stack to avoid function call overhead | |
| stack = [func_node] | |
| nested_func_types = frozenset([ | |
| "function_declaration", | |
| "arrow_function", | |
| "function", | |
| "method_definition", | |
| ]) | |
| while stack: | |
| node = stack.pop() | |
| # Don't descend into nested functions | |
| if node != func_node and node.type in nested_func_types: | |
| continue | |
| if node.type == "return_statement": | |
| # Check if return value contains JSX | |
| for child in node.children: | |
| if _contains_jsx(child): | |
| returns.append(node) | |
| break | |
| else: | |
| stack.extend(reversed(node.children)) | |
Comment on lines
+163
to
+165
| if node.type in ("jsx_element", "jsx_self_closing_element", "jsx_fragment"): | ||
| return True | ||
| return any(_contains_jsx(child) for child in node.children) |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 449% (4.49x) speedup for _contains_jsx in codeflash/languages/javascript/frameworks/react/profiler.py
⏱️ Runtime : 465 microseconds → 84.8 microseconds (best of 250 runs)
📝 Explanation and details
The refinement preserves the core optimization (stack-based iteration with early exit) while improving code quality:-
Removed jsx_types set: The profiler showed set creation taking 4.4% of execution time. For only 3 items, a tuple is more efficient and avoids per-call construction overhead. This also reduces the diff by keeping the same tuple literal as the original.
-
Preserved the optimization: The stack-based iterative approach with early exit remains intact, providing the ~470% speedup by:
- Eliminating recursion overhead
- Stopping immediately when JSX is found (vs. the original's
any()which must create and evaluate the entire generator)
-
Maintained readability: Removed unnecessary blank lines to match the original's compactness while keeping the code clear.
The refined version maintains the full performance benefit while being closer to the original code style and avoiding the unnecessary set construction overhead.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 29 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest
from codeflash.languages.javascript.frameworks.react.profiler import \
_contains_jsx
# function to test
from tree_sitter import Language, Node, Parser
# Helper class to simulate tree-sitter nodes without using mocks
class MockNode:
"""A simple node class that mimics tree-sitter Node behavior."""
def __init__(self, node_type, children):
"""Initialize a MockNode with a type and children.
Args:
node_type: The string type of this node (e.g., "jsx_element")
children: A list of MockNode children
"""
self.type = node_type
self.children = children
class TestContainsJsxBasic:
"""Basic tests for _contains_jsx function."""
def test_jsx_element_direct_match(self):
"""Test that a jsx_element node returns True."""
# Create a mock node with type jsx_element
node = MockNode(node_type="jsx_element", children=[])
codeflash_output = _contains_jsx(node) # 410ns -> 641ns (36.0% slower)
def test_jsx_self_closing_element_direct_match(self):
"""Test that a jsx_self_closing_element node returns True."""
# Create a mock node with type jsx_self_closing_element
node = MockNode(node_type="jsx_self_closing_element", children=[])
codeflash_output = _contains_jsx(node) # 421ns -> 711ns (40.8% slower)
def test_jsx_fragment_direct_match(self):
"""Test that a jsx_fragment node returns True."""
# Create a mock node with type jsx_fragment
node = MockNode(node_type="jsx_fragment", children=[])
codeflash_output = _contains_jsx(node) # 431ns -> 701ns (38.5% slower)
def test_non_jsx_node_no_children(self):
"""Test that a non-JSX node with no children returns False."""
# Create a node that is not a JSX type
node = MockNode(node_type="identifier", children=[])
codeflash_output = _contains_jsx(node) # 1.11μs -> 882ns (26.1% faster)
def test_non_jsx_node_with_non_jsx_children(self):
"""Test that a non-JSX node with only non-JSX children returns False."""
# Create child nodes that are not JSX types
child1 = MockNode(node_type="identifier", children=[])
child2 = MockNode(node_type="property_identifier", children=[])
# Create a parent node with non-JSX children
node = MockNode(node_type="object", children=[child1, child2])
codeflash_output = _contains_jsx(node) # 1.97μs -> 1.48μs (33.1% faster)
def test_jsx_element_as_child(self):
"""Test that a non-JSX node with a jsx_element child returns True."""
# Create a jsx_element child
jsx_child = MockNode(node_type="jsx_element", children=[])
# Create a parent node with the JSX child
node = MockNode(node_type="return_statement", children=[jsx_child])
codeflash_output = _contains_jsx(node) # 1.77μs -> 992ns (78.7% faster)
def test_jsx_element_nested_deeply(self):
"""Test that a jsx_element nested multiple levels deep is found."""
# Create a deeply nested structure: root -> intermediate -> jsx_element
jsx_element = MockNode(node_type="jsx_element", children=[])
intermediate = MockNode(node_type="expression_statement", children=[jsx_element])
root = MockNode(node_type="program", children=[intermediate])
codeflash_output = _contains_jsx(root) # 2.26μs -> 1.09μs (107% faster)
def test_multiple_children_with_jsx_in_middle(self):
"""Test that JSX is found when it's one of multiple children."""
# Create multiple children, with JSX in the middle
child1 = MockNode(node_type="identifier", children=[])
jsx_child = MockNode(node_type="jsx_self_closing_element", children=[])
child3 = MockNode(node_type="number", children=[])
# Create parent with multiple children
node = MockNode(node_type="array", children=[child1, jsx_child, child3])
codeflash_output = _contains_jsx(node) # 2.27μs -> 1.33μs (70.7% faster)
class TestContainsJsxEdgeCases:
"""Edge case tests for _contains_jsx function."""
def test_node_with_empty_children_list(self):
"""Test that a node with an empty children list behaves correctly."""
# A node with no children should return False if it's not a JSX type
node = MockNode(node_type="empty_statement", children=[])
codeflash_output = _contains_jsx(node) # 1.05μs -> 861ns (22.2% faster)
def test_node_type_case_sensitivity(self):
"""Test that node type matching is case-sensitive."""
# Create a node with uppercase JSX type (should not match)
node = MockNode(node_type="JSX_ELEMENT", children=[])
codeflash_output = _contains_jsx(node) # 1.04μs -> 912ns (14.3% faster)
def test_node_type_with_similar_name(self):
"""Test that similar but different node types don't match."""
# Create nodes with names similar to JSX types
node1 = MockNode(node_type="jsx_element_child", children=[])
node2 = MockNode(node_type="jsx_elements", children=[])
node3 = MockNode(node_type="jsx", children=[])
codeflash_output = _contains_jsx(node1) # 1.03μs -> 872ns (18.3% faster)
codeflash_output = _contains_jsx(node2) # 541ns -> 431ns (25.5% faster)
codeflash_output = _contains_jsx(node3) # 431ns -> 300ns (43.7% faster)
def test_jsx_fragment_with_children(self):
"""Test that a jsx_fragment with children still returns True."""
# A jsx_fragment should return True regardless of its children
child = MockNode(node_type="identifier", children=[])
jsx_fragment = MockNode(node_type="jsx_fragment", children=[child])
codeflash_output = _contains_jsx(jsx_fragment) # 461ns -> 691ns (33.3% slower)
def test_all_three_jsx_types_in_same_subtree(self):
"""Test that any of the three JSX types is detected."""
# Create a structure with all three JSX types
jsx_element = MockNode(node_type="jsx_element", children=[])
jsx_self_closing = MockNode(node_type="jsx_self_closing_element", children=[])
jsx_fragment = MockNode(node_type="jsx_fragment", children=[])
# Each should return True independently
codeflash_output = _contains_jsx(jsx_element) # 361ns -> 631ns (42.8% slower)
codeflash_output = _contains_jsx(jsx_self_closing) # 260ns -> 340ns (23.5% slower)
codeflash_output = _contains_jsx(jsx_fragment) # 181ns -> 250ns (27.6% slower)
def test_long_chain_of_non_jsx_then_jsx(self):
"""Test that JSX is found after a long chain of non-JSX nodes."""
# Create a long chain: node1 -> node2 -> node3 -> jsx
jsx = MockNode(node_type="jsx_element", children=[])
node3 = MockNode(node_type="call_expression", children=[jsx])
node2 = MockNode(node_type="expression_statement", children=[node3])
node1 = MockNode(node_type="program", children=[node2])
codeflash_output = _contains_jsx(node1) # 2.77μs -> 1.26μs (119% faster)
def test_multiple_siblings_with_jsx_in_first(self):
"""Test that JSX in first sibling is found."""
jsx = MockNode(node_type="jsx_element", children=[])
sibling1 = MockNode(node_type="identifier", children=[])
sibling2 = MockNode(node_type="number", children=[])
parent = MockNode(node_type="array", children=[jsx, sibling1, sibling2])
codeflash_output = _contains_jsx(parent) # 1.75μs -> 1.58μs (10.7% faster)
def test_multiple_siblings_with_jsx_in_last(self):
"""Test that JSX in last sibling is found."""
sibling1 = MockNode(node_type="identifier", children=[])
sibling2 = MockNode(node_type="number", children=[])
jsx = MockNode(node_type="jsx_element", children=[])
parent = MockNode(node_type="array", children=[sibling1, sibling2, jsx])
codeflash_output = _contains_jsx(parent) # 2.48μs -> 1.07μs (131% faster)
def test_wide_tree_with_jsx_deep_in_branch(self):
"""Test finding JSX in a wide tree with many branches."""
# Create many siblings, with JSX deep in one branch
jsx = MockNode(node_type="jsx_self_closing_element", children=[])
deep_branch = MockNode(node_type="expression_statement", children=[jsx])
siblings = [MockNode(node_type="identifier", children=[]) for _ in range(5)]
siblings[2] = deep_branch # Insert deep branch as one of the siblings
parent = MockNode(node_type="array", children=siblings)
codeflash_output = _contains_jsx(parent) # 3.07μs -> 1.56μs (96.2% faster)
def test_tree_with_multiple_jsx_nodes(self):
"""Test that function returns True when multiple JSX nodes exist."""
jsx1 = MockNode(node_type="jsx_element", children=[])
jsx2 = MockNode(node_type="jsx_fragment", children=[])
non_jsx = MockNode(node_type="identifier", children=[])
parent = MockNode(node_type="program", children=[jsx1, non_jsx, jsx2])
codeflash_output = _contains_jsx(parent) # 1.73μs -> 1.10μs (57.3% faster)
class TestContainsJsxLargeScale:
"""Large-scale tests for _contains_jsx function."""
def test_large_tree_without_jsx(self):
"""Test performance with a large tree containing no JSX."""
# Create a deep tree with many nodes, no JSX
current = MockNode(node_type="identifier", children=[])
for _ in range(100):
current = MockNode(node_type="expression", children=[current])
codeflash_output = _contains_jsx(current) # 64.3μs -> 9.47μs (579% faster)
def test_large_tree_with_jsx_at_root(self):
"""Test large tree where root is JSX."""
# Create a jsx_element with many children
children = [MockNode(node_type="identifier", children=[]) for _ in range(50)]
jsx_root = MockNode(node_type="jsx_element", children=children)
codeflash_output = _contains_jsx(jsx_root) # 421ns -> 651ns (35.3% slower)
def test_large_tree_with_jsx_at_bottom(self):
"""Test large tree where JSX is at the deepest level."""
# Create a deep tree with JSX at the bottom
jsx = MockNode(node_type="jsx_fragment", children=[])
current = jsx
for _ in range(100):
current = MockNode(node_type="expression", children=[current])
codeflash_output = _contains_jsx(current) # 81.3μs -> 9.42μs (764% faster)
def test_wide_tree_no_jsx(self):
"""Test a very wide tree (many children) without JSX."""
# Create a node with many children, none of which are JSX
children = [MockNode(node_type="identifier", children=[]) for _ in range(100)]
parent = MockNode(node_type="array", children=children)
codeflash_output = _contains_jsx(parent) # 29.6μs -> 10.0μs (194% faster)
def test_wide_tree_with_jsx_last_child(self):
"""Test a wide tree where JSX is the last child."""
# Create many children with JSX as the last one
children = [MockNode(node_type="identifier", children=[]) for _ in range(99)]
children.append(MockNode(node_type="jsx_element", children=[]))
parent = MockNode(node_type="array", children=children)
codeflash_output = _contains_jsx(parent) # 29.9μs -> 1.47μs (1927% faster)
def test_balanced_tree_with_jsx(self):
"""Test a balanced binary-like tree with JSX in one branch."""
# Create a balanced tree structure
jsx = MockNode(node_type="jsx_element", children=[])
left_child = jsx
right_child = MockNode(node_type="identifier", children=[])
for _ in range(10):
left_child = MockNode(node_type="expression", children=[left_child])
right_child = MockNode(node_type="expression", children=[right_child])
root = MockNode(node_type="program", children=[left_child, right_child])
codeflash_output = _contains_jsx(root) # 6.50μs -> 3.92μs (66.0% faster)
def test_many_nested_non_jsx_then_one_jsx(self):
"""Test very deep nesting with JSX at the very bottom."""
# Create a chain 200 nodes deep with JSX at the end
jsx = MockNode(node_type="jsx_self_closing_element", children=[])
current = jsx
for _ in range(200):
current = MockNode(node_type="wrapper", children=[current])
codeflash_output = _contains_jsx(current) # 179μs -> 17.5μs (926% faster)
def test_complex_tree_jsx_in_middle_depth(self):
"""Test complex tree with JSX at mid-depth."""
# Create a structure: root with many children, JSX in middle depth
jsx = MockNode(node_type="jsx_fragment", children=[])
middle = MockNode(node_type="expression", children=[jsx])
children = [MockNode(node_type="identifier", children=[]) for _ in range(10)]
children[5] = middle
root = MockNode(node_type="program", children=children)
codeflash_output = _contains_jsx(root) # 3.93μs -> 1.74μs (125% faster)
def test_array_of_mostly_non_jsx_with_one_jsx(self):
"""Test an array-like structure with one JSX among many non-JSX."""
# Create a large array with JSX hidden in the middle
children = [MockNode(node_type=f"element_{i}", children=[]) for i in range(100)]
children[50] = MockNode(node_type="jsx_element", children=[])
parent = MockNode(node_type="array", children=children)
codeflash_output = _contains_jsx(parent) # 16.3μs -> 5.47μs (198% faster)
def test_deeply_nested_jsx_containers(self):
"""Test deeply nested containers around a JSX node."""
# Create: container -> container -> ... -> jsx
jsx = MockNode(node_type="jsx_element", children=[])
current = jsx
for _ in range(50):
current = MockNode(node_type="container", children=[current])
codeflash_output = _contains_jsx(current) # 25.9μs -> 5.42μs (377% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T06.25.12
Suggested change
| 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 |
I combined the two child-iteration passes in _wrap_return_with_profiler into a single loop (while still preserving the original parenthesis-handling semantics), and replaced the generator-based any(...) in _contains_jsx with an explicit loop to avoid generator overhead. I also delay decoding bytes until after determining the final slice to avoid redundant encodings/decodings. These changes reduce CPU work and memory churn while preserving exact behavior.
Contributor
⚡️ Codeflash found optimizations for this PR📄 30% (0.30x) speedup for
|
Comment on lines
+101
to
+114
| if "act(" in result and "import" in result and "act" not in result.split("from '@testing-library/react'")[0]: | ||
| result = result.replace("from '@testing-library/react'", "act, " + "from '@testing-library/react'", 1) | ||
|
|
||
| # Ensure user-event import if user interactions are tested | ||
| if ( | ||
| "click" in result.lower() or "type" in result.lower() or "userEvent" in result | ||
| ) and "@testing-library/user-event" not in result: | ||
| # Add user-event import after testing-library import | ||
| result = re.sub( | ||
| r"(import .+ from '@testing-library/react';?\n)", | ||
| r"\1import userEvent from '@testing-library/user-event';\n", | ||
| result, | ||
| count=1, | ||
| ) |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 47% (0.47x) speedup for post_process_react_tests in codeflash/languages/javascript/frameworks/react/testgen.py
⏱️ Runtime : 637 microseconds → 434 microseconds (best of 228 runs)
📝 Explanation and details
This optimization achieves a 46% runtime improvement (637μs → 434μs) by eliminating expensive regex operations and redundant string processing in React test post-processing.
Key Optimizations:
-
Replaced expensive
re.sub()with direct string manipulation: The original code used regex substitution to insert the user-event import (69% of runtime). The optimized version usesfind()and string slicing to locate the insertion point and construct the result directly, eliminating regex compilation and pattern matching overhead. -
Single
lower()call for multiple checks: Instead of callingresult.lower()twice when checking for "click" and "type", the optimized version computeslower_resultonce and reuses it (reduced from 11.7% to 7.9% of runtime). -
Simplified
actimport detection: Changed from creating a split list withresult.split("from '@testing-library/react'")to usingfind()and string slicing, which is more efficient for single-occurrence searches.
Performance Impact by Test Case:
The optimization excels when user-event imports need to be added:
- Simple click detection: 279% faster (9.88μs → 2.60μs)
- Type interaction detection: 242% faster (9.94μs → 2.90μs)
- Mixed case detection: 248% faster (9.76μs → 2.81μs)
- Large files with 1000 clicks: 17.2% faster (47.5μs → 40.5μs)
- Complex import patterns (60 variations): 164% faster (184μs → 70.2μs)
For simple cases without regex (already-imported tests), performance is comparable or slightly better (1-5% improvement).
Functional Context:
Based on function_references, this function is called in test generation pipelines to post-process LLM-generated React tests. The optimization is particularly valuable when:
- Processing many test files in batch (CI/CD scenarios)
- LLM generates tests without proper imports (the common case triggering regex)
- Large test files with multiple interaction patterns
The optimization maintains identical output while dramatically reducing processing time for the regex-heavy code path, making test generation and validation pipelines significantly faster.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 98 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
from codeflash.languages.javascript.frameworks.react.discovery import \
ReactComponentInfo
from codeflash.languages.javascript.frameworks.react.testgen import \
post_process_react_tests
def test_adds_testing_library_import_when_missing():
# Simple source without any imports should get the testing-library import prepended.
src = "describe('My test', () => {\n // test body\n});\n"
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 1.63μs -> 1.55μs (5.15% faster)
def test_preserves_existing_testing_library_import():
# If the source already imports from testing-library, it should not add another identical import.
src = "import { render, screen } from '@testing-library/react';\n\nit('works', () => {});\n"
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 1.46μs -> 1.41μs (3.54% faster)
def test_inserts_act_token_when_act_is_used_but_not_in_import():
# When act(...) is used in the body but the existing import doesn't include 'act',
# the implementation attempts to inject "act, " before "from '@testing-library/react'".
src = "import { render, screen } from '@testing-library/react';\n\n// some test\nact(() => { /* state update */ });\n"
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 2.94μs -> 3.19μs (7.85% slower)
def test_adds_user_event_when_click_detected_and_import_missing():
# If the test mentions clicks and testing-library import is missing, both testing-library and user-event imports are added.
src = "test('click test', () => {\n button.click();\n});\n"
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 9.88μs -> 2.60μs (279% faster)
def test_does_not_duplicate_user_event_if_already_present():
# If the source already imports from @testing-library/user-event, no additional userEvent import should be added.
src = (
"import { render, screen } from '@testing-library/react';\n"
"import userEvent from '@testing-library/user-event';\n\n"
"it('clicks', () => {\n button.click();\n});\n"
)
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 1.41μs -> 1.45μs (2.75% slower)
def test_type_in_subword_triggers_user_event_insertion():
# The code lowercases and searches for 'type', so even substrings like 'prototype' will trigger insertion.
src = "function prototypeThing() { /* prototype contains 'type' */ }\n"
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 9.94μs -> 2.90μs (242% faster)
def test_empty_input_returns_testing_library_import_only():
# An empty source should result in just the testing-library import being added.
src = ""
info = ReactComponentInfo("MyComponent", "function")
codeflash_output = post_process_react_tests(src, info); out = codeflash_output # 1.22μs -> 1.25μs (2.32% slower)
def test_large_scale_many_clicks_only_one_user_event_import_and_idempotent():
# Build a large source with many click() occurrences (1000),
# and ensure only one user-event import is added and the function is idempotent when run twice.
lines = ["// large test file"]
# Add 1000 lines that include the substring 'click' to trigger user-event insertion
for i in range(1000):
lines.append(f"element_{i}.click();")
src = "\n".join(lines) + "\n"
info = ReactComponentInfo("BigComponent", "function")
codeflash_output = post_process_react_tests(src, info); out_once = codeflash_output # 47.5μs -> 40.5μs (17.2% faster)
# Running the processor again should not add more imports (idempotence)
codeflash_output = post_process_react_tests(out_once, info); out_twice = codeflash_output # 21.1μs -> 21.1μs (0.047% slower)
# Ensure that none of the original click lines were removed
for i in (0, 500, 999): # sample checks rather than all 1000 for performance
pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.from enum import Enum
# imports
import pytest
from codeflash.languages.javascript.frameworks.react.discovery import \
ReactComponentInfo
from codeflash.languages.javascript.frameworks.react.testgen import \
post_process_react_tests
# Define ComponentType enum (required for ReactComponentInfo construction)
class ComponentType(Enum):
"""Enum for React component types."""
FUNCTIONAL = "functional"
CLASS = "class"
HOOK = "hook"
def test_adds_testing_library_import_when_missing():
"""Test that testing-library import is added when completely absent."""
# Arrange: Create a test source without any testing-library imports
test_source = "describe('MyComponent', () => { test('renders', () => {}); });"
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.64μs -> 1.62μs (1.23% faster)
def test_preserves_existing_testing_library_import():
"""Test that existing testing-library import is not duplicated."""
# Arrange: Create a test source with existing testing-library import
test_source = "import { render } from '@testing-library/react';\ntest('renders', () => {});"
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.40μs -> 1.42μs (1.41% slower)
def test_adds_user_event_import_for_click_interactions():
"""Test that user-event import is added when click interactions are detected."""
# Arrange: Create a test source with click interaction but no user-event import
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('clicks button', () => { screen.getByRole('button').click(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 10.1μs -> 2.85μs (253% faster)
def test_adds_user_event_import_for_type_interactions():
"""Test that user-event import is added when type interactions are detected."""
# Arrange: Create a test source with type interaction but no user-event import
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('types in input', () => { userEvent.type(screen.getByRole('textbox'), 'hello'); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 9.93μs -> 3.03μs (228% faster)
def test_preserves_existing_user_event_import():
"""Test that existing user-event import is not duplicated."""
# Arrange: Create a test source with both imports and click interaction
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"import userEvent from '@testing-library/user-event';\n"
"test('clicks', () => { screen.getByRole('button').click(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.41μs -> 1.39μs (1.51% faster)
def test_no_user_event_import_without_interactions():
"""Test that user-event import is not added when there are no interactions."""
# Arrange: Create a simple test source without click/type
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('renders text', () => { expect(screen.getByText('hello')).toBeInTheDocument(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.75μs -> 1.81μs (3.31% slower)
def test_handles_mixed_case_click_detection():
"""Test that click detection is case-insensitive."""
# Arrange: Create test source with CLICK in uppercase
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('test', () => { element.CLICK(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 9.76μs -> 2.81μs (248% faster)
def test_returns_string_type():
"""Test that the function returns a string."""
# Arrange: Create a simple test source
test_source = "test('renders', () => {});"
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.43μs -> 1.45μs (1.38% slower)
def test_empty_test_source():
"""Test handling of empty test source string."""
# Arrange: Create an empty test source
test_source = ""
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.26μs -> 1.30μs (3.15% slower)
def test_whitespace_only_source():
"""Test handling of whitespace-only test source."""
# Arrange: Create a test source with only whitespace
test_source = " \n \t \n "
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.43μs -> 1.38μs (3.69% faster)
def test_multiline_test_source():
"""Test handling of multiline test source with comments."""
# Arrange: Create a complex multiline test source
test_source = """
// Component test suite
describe('MyComponent', () => {
// Test 1
test('should render', () => {
render(<MyComponent />);
expect(screen.getByText('Hello')).toBeInTheDocument();
});
});
"""
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 2.62μs -> 2.40μs (9.15% faster)
def test_source_with_act_wrapping_detection():
"""Test that act() wrapping is preserved when present."""
# Arrange: Create a test source with act() already present
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('updates state', () => { act(() => { setState(true); }); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 2.31μs -> 2.63μs (12.2% slower)
def test_source_with_special_characters():
"""Test handling of test source with special characters and escape sequences."""
# Arrange: Create a test source with special characters
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('renders text with special chars: !@#$%^&*()', () => { "
"expect(screen.getByText(/pattern/)).toBeInTheDocument(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.85μs -> 1.76μs (5.05% faster)
def test_component_with_different_types():
"""Test that function works with different ComponentType values."""
# Arrange: Create test sources for different component types
test_source = "test('renders', () => {});"
for component_type in [ComponentType.FUNCTIONAL, ComponentType.CLASS, ComponentType.HOOK]:
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=component_type
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 2.92μs -> 2.85μs (2.81% faster)
def test_source_with_multiple_act_occurrences():
"""Test handling of test source with multiple act() calls."""
# Arrange: Create test source with multiple act() calls
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('multiple updates', () => { "
"act(() => { setState(1); }); "
"act(() => { setState(2); }); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 2.34μs -> 2.56μs (8.58% slower)
def test_source_with_click_in_comment():
"""Test that click in comments still triggers user-event import."""
# Arrange: Create test source with 'click' only in a comment
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"// TODO: test click behavior\n"
"test('renders', () => {});"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 9.93μs -> 2.71μs (266% faster)
def test_source_with_type_in_string_literal():
"""Test that 'type' in string literals triggers user-event import."""
# Arrange: Create test source with 'type' in a string
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('displays type information', () => { "
"expect(screen.getByText('string type')).toBeInTheDocument(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 9.98μs -> 2.98μs (235% faster)
def test_source_with_userEvent_reference():
"""Test detection of userEvent reference."""
# Arrange: Create test source referencing userEvent
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('user interaction', () => { userEvent.clear(input); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 9.65μs -> 3.00μs (222% faster)
def test_component_info_with_all_optional_parameters():
"""Test function with component info containing all optional parameters."""
# Arrange: Create component info with all optional parameters set
test_source = "test('renders', () => {});"
component_info = ReactComponentInfo(
function_name="ComplexComponent",
component_type=ComponentType.FUNCTIONAL,
uses_hooks=("useState", "useEffect"),
returns_jsx=True,
props_type="Props",
is_memoized=True,
start_line=10,
end_line=50
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.39μs -> 1.30μs (6.83% faster)
def test_source_with_only_import_statements():
"""Test handling of source containing only import statements."""
# Arrange: Create source with only imports, no test code
test_source = (
"import React from 'react';\n"
"import MyComponent from './MyComponent';"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.57μs -> 1.49μs (5.29% faster)
def test_source_with_nested_quotes():
"""Test handling of source with nested quotes."""
# Arrange: Create test source with nested quotes
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
"test('nested quotes', () => { "
"expect(screen.getByText(\"it's working\")).toBeInTheDocument(); });"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 1.77μs -> 1.66μs (6.61% faster)
def test_large_test_file_with_many_tests():
"""Test processing of a large test file with many test cases."""
# Arrange: Create a large test source with 100 test cases
test_cases = []
for i in range(100):
test_cases.append(f"test('test {i}', () => {{ expect(true).toBe(true); }});")
test_source = "\n".join(test_cases)
component_info = ReactComponentInfo(
function_name="LargeComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 18.7μs -> 16.6μs (12.8% faster)
def test_large_test_file_with_many_click_interactions():
"""Test processing of large test file with 200 click interactions."""
# Arrange: Create test source with 200 click interactions
test_cases = []
for i in range(200):
test_cases.append(
f"test('click test {i}', () => {{ "
f"element.click(); expect(state).toBe({i}); }});"
)
test_source = "import { render, screen, act } from '@testing-library/react';\n" + "\n".join(test_cases)
component_info = ReactComponentInfo(
function_name="InteractiveComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 30.0μs -> 22.8μs (31.4% faster)
def test_very_long_single_test_case():
"""Test processing of a single very long test case."""
# Arrange: Create a single test with a very long assertion chain (500+ characters)
long_assertion = " && ".join([f"test{i}" for i in range(100)])
test_source = (
f"test('very long test', () => {{ "
f"expect({long_assertion}).toBe(true); }});"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 5.03μs -> 4.61μs (9.14% faster)
def test_source_with_many_act_wrappings():
"""Test processing of test source with 500 act() wrappings."""
# Arrange: Create test source with many act() calls
act_calls = "\n".join([f"act(() => {{ setState({i}); }});" for i in range(500)])
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
f"test('many updates', () => {{ {act_calls} }});"
)
component_info = ReactComponentInfo(
function_name="StateComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 38.9μs -> 30.3μs (28.3% faster)
def test_source_with_many_imports_already_present():
"""Test processing when many imports already exist."""
# Arrange: Create test source with 50 existing imports
imports = "\n".join([f"import Component{i} from './Component{i}';" for i in range(50)])
test_source = (
"import { render, screen, act } from '@testing-library/react';\n"
f"{imports}\n"
"test('renders', () => {});"
)
component_info = ReactComponentInfo(
function_name="MyComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 7.53μs -> 6.65μs (13.3% faster)
def test_performance_with_very_large_source():
"""Test that function performs efficiently with very large source (50KB+)."""
# Arrange: Create a very large test source with 1000 lines
lines = []
lines.append("import { render, screen, act } from '@testing-library/react';")
for i in range(1000):
lines.append(
f"test('test {i}', () => {{ "
f"const var{i} = 'value{i}'; "
f"expect(screen.getByText(var{i})).toBeInTheDocument(); "
f"element.click(); }});"
)
test_source = "\n".join(lines)
component_info = ReactComponentInfo(
function_name="MassiveComponent",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 168μs -> 162μs (3.92% faster)
def test_regex_replacement_with_complex_import_patterns():
"""Test regex import replacement with various testing-library import patterns."""
# Arrange: Create test source with various import patterns (300 different patterns)
import_patterns = [
"import { render } from '@testing-library/react';",
"import { render, screen } from '@testing-library/react';",
"import { render, screen, act } from '@testing-library/react';",
"import { act } from '@testing-library/react';",
"import * as RTL from '@testing-library/react';",
]
for i in range(60):
pattern = import_patterns[i % len(import_patterns)]
test_source = (
f"{pattern}\n"
f"test('test {i}', () => {{ "
f"element.click(); expect(true).toBe(true); }});"
)
component_info = ReactComponentInfo(
function_name=f"Component{i}",
component_type=ComponentType.FUNCTIONAL
)
# Act: Post-process the test source
codeflash_output = post_process_react_tests(test_source, component_info); result = codeflash_output # 184μs -> 70.2μs (164% faster)
# Ensure user-event import comes after testing-library import
idx_react = result.find("@testing-library/react")
idx_user = result.find("@testing-library/user-event")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T06.51.38
Click to see suggested changes
Suggested change
| if "act(" in result and "import" in result and "act" not in result.split("from '@testing-library/react'")[0]: | |
| result = result.replace("from '@testing-library/react'", "act, " + "from '@testing-library/react'", 1) | |
| # Ensure user-event import if user interactions are tested | |
| if ( | |
| "click" in result.lower() or "type" in result.lower() or "userEvent" in result | |
| ) and "@testing-library/user-event" not in result: | |
| # Add user-event import after testing-library import | |
| result = re.sub( | |
| r"(import .+ from '@testing-library/react';?\n)", | |
| r"\1import userEvent from '@testing-library/user-event';\n", | |
| result, | |
| count=1, | |
| ) | |
| if "act(" in result and "import" in result: | |
| # Replicate original behavior: check for "act" to the left of the first occurrence | |
| split_pos = result.find("from '@testing-library/react'") | |
| left = result[:split_pos] if split_pos != -1 else result | |
| if "act" not in left: | |
| result = result.replace("from '@testing-library/react'", "act, " + "from '@testing-library/react'", 1) | |
| # Ensure user-event import if user interactions are tested | |
| # compute lowercase once to avoid repeated lower() calls | |
| lower_result = result.lower() | |
| # Ensure user-event import if user interactions are tested | |
| if ( | |
| ("click" in lower_result or "type" in lower_result or "userEvent" in result) | |
| and "@testing-library/user-event" not in result | |
| ): | |
| # Try to find an import line for testing-library that ends with an optional semicolon and a newline, | |
| # matching the original regex behavior which required a trailing newline. | |
| anchor = "from '@testing-library/react'" | |
| pos = result.find(anchor) | |
| if pos != -1: | |
| idx_after = pos + len(anchor) | |
| # optional semicolon | |
| if idx_after < len(result) and result[idx_after] == ';': | |
| idx_after += 1 | |
| # require a newline after the optional semicolon to match original pattern's \n | |
| if idx_after < len(result) and result[idx_after] == '\n': | |
| insertion_point = idx_after + 1 # after the newline | |
| result = ( | |
| result[:insertion_point] | |
| + "import userEvent from '@testing-library/user-event';\n" | |
| + result[insertion_point:] | |
| ) | |
| else: | |
| # If the exact pattern with trailing newline wasn't found, fall back to regex | |
| # to preserve original behavior in edge cases. | |
| result = re.sub( | |
| r"(import .+ from '@testing-library/react';?\n)", | |
| r"\1import userEvent from '@testing-library/user-event';\n", | |
| result, | |
| count=1, | |
| ) |
…2026-02-20T06.29.37 ⚡️ Speed up function `_wrap_return_with_profiler` by 30% in PR #1561 (`add/support_react`)
Contributor
|
This PR is now faster! 🚀 @claude[bot] accepted my optimizations from: |
Comment on lines
+83
to
+98
| lines = [ | ||
| "### React Render Performance", | ||
| "", | ||
| "| Metric | Before | After | Improvement |", | ||
| "|--------|--------|-------|-------------|", | ||
| f"| Renders | {benchmark.original_render_count} | {benchmark.optimized_render_count} " | ||
| f"| {benchmark.render_count_reduction_pct:.1f}% fewer |", | ||
| f"| Avg render time | {benchmark.original_avg_duration_ms:.2f}ms " | ||
| f"| {benchmark.optimized_avg_duration_ms:.2f}ms " | ||
| f"| {benchmark.duration_reduction_pct:.1f}% faster |", | ||
| ] | ||
|
|
||
| if benchmark.render_speedup_x > 1: | ||
| lines.append(f"\nRender time improved **{benchmark.render_speedup_x:.1f}x**.") | ||
|
|
||
| return "\n".join(lines) |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 17% (0.17x) speedup for format_render_benchmark_for_pr in codeflash/languages/javascript/frameworks/react/benchmarking.py
⏱️ Runtime : 103 microseconds → 87.9 microseconds (best of 136 runs)
📝 Explanation and details
This optimization achieves a 17% runtime improvement by replacing list-based string building with direct string concatenation, eliminating unnecessary list operations that were the primary performance bottleneck.
Key Changes:
-
Eliminated list construction and joining overhead - The original code built a list of 7-8 strings then called
"\n".join(lines), which the line profiler shows took ~60.9μs (9.6% of total time). The optimized version uses a single multi-line string literal concatenated directly, eliminating both list allocation (~21.8μs for the initial list) and the join operation. -
Direct string concatenation - Instead of appending to a list and joining, the code now builds the result string incrementally using
+=for the conditional speedup message. This is more efficient for this small, fixed number of string segments. -
Preserved conditional logic - The
if benchmark.render_speedup_x > 1check remains identical, maintaining the same behavior while benefiting from the more efficient string building approach.
Why This Is Faster:
- Python's list operations (allocation, appending, iteration during join) add overhead that's unnecessary when the number of strings is small and known
- Modern Python optimizes string concatenation reasonably well for this pattern (a few concatenations)
- The multi-line string literal is parsed once at compile time, reducing runtime string construction overhead
- Eliminating the join operation saves both the function call and the iteration over list elements
Impact on Workloads:
The function is called from test_react_e2e.py in the benchmarking and PR formatting workflow. Given the test shows this function being called to format React render performance data for PR comments, this 17% speedup will make benchmark report generation noticeably faster, especially when processing multiple components or running in CI/CD pipelines where many benchmarks are formatted.
Test Results:
All test cases show consistent improvements (12-25% faster), with the largest gains in simpler cases (e.g., test_zero_speedup_does_not_include_speedup_message at 25.8% faster) where the list overhead was proportionally higher compared to the actual string formatting work.
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 31 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest
from codeflash.languages.javascript.frameworks.react.benchmarking import \
format_render_benchmark_for_pr
# We need to import or define the RenderBenchmark class
# Based on the function signature and usage, we can infer its structure
class RenderBenchmark:
"""A simple data class to hold render benchmark metrics."""
def __init__(
self,
original_render_count: int,
optimized_render_count: int,
render_count_reduction_pct: float,
original_avg_duration_ms: float,
optimized_avg_duration_ms: float,
duration_reduction_pct: float,
render_speedup_x: float,
):
self.original_render_count = original_render_count
self.optimized_render_count = optimized_render_count
self.render_count_reduction_pct = render_count_reduction_pct
self.original_avg_duration_ms = original_avg_duration_ms
self.optimized_avg_duration_ms = optimized_avg_duration_ms
self.duration_reduction_pct = duration_reduction_pct
self.render_speedup_x = render_speedup_x
def test_basic_functionality_with_positive_improvements():
"""Test formatting with typical positive benchmark improvements."""
# Create a benchmark with realistic improvement metrics
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.50,
optimized_avg_duration_ms=5.25,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.72μs -> 4.09μs (15.5% faster)
def test_output_structure_has_markdown_table():
"""Test that output contains proper markdown table structure."""
benchmark = RenderBenchmark(
original_render_count=200,
optimized_render_count=100,
render_count_reduction_pct=50.0,
original_avg_duration_ms=20.00,
optimized_avg_duration_ms=10.00,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.02μs -> 3.40μs (18.3% faster)
# Verify markdown table structure with pipes
lines = result.split("\n")
def test_zero_speedup_does_not_include_speedup_message():
"""Test that speedup message is not included when render_speedup_x <= 1."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=100,
render_count_reduction_pct=0.0,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=10.00,
duration_reduction_pct=0.0,
render_speedup_x=1.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.42μs -> 2.71μs (25.8% faster)
def test_decimal_formatting_two_places_for_duration():
"""Test that duration values are formatted to exactly 2 decimal places."""
benchmark = RenderBenchmark(
original_render_count=50,
optimized_render_count=25,
render_count_reduction_pct=50.0,
original_avg_duration_ms=15.123,
optimized_avg_duration_ms=7.456,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.05μs -> 3.54μs (14.4% faster)
def test_decimal_formatting_one_place_for_percentages():
"""Test that percentage values are formatted to exactly 1 decimal place."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=67,
render_count_reduction_pct=33.333333,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=6.667,
duration_reduction_pct=33.333333,
render_speedup_x=1.5,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.93μs -> 3.35μs (17.4% faster)
def test_integer_render_counts_displayed_as_integers():
"""Test that render counts are displayed as integers without decimal points."""
benchmark = RenderBenchmark(
original_render_count=999,
optimized_render_count=111,
render_count_reduction_pct=88.9,
original_avg_duration_ms=50.00,
optimized_avg_duration_ms=5.60,
duration_reduction_pct=88.8,
render_speedup_x=8.9,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.84μs -> 3.35μs (14.7% faster)
def test_zero_render_counts():
"""Test with zero render counts."""
benchmark = RenderBenchmark(
original_render_count=0,
optimized_render_count=0,
render_count_reduction_pct=0.0,
original_avg_duration_ms=0.00,
optimized_avg_duration_ms=0.00,
duration_reduction_pct=0.0,
render_speedup_x=1.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.08μs -> 2.50μs (23.2% faster)
def test_very_large_render_counts():
"""Test with very large render count values."""
benchmark = RenderBenchmark(
original_render_count=1000000,
optimized_render_count=500000,
render_count_reduction_pct=50.0,
original_avg_duration_ms=100.00,
optimized_avg_duration_ms=50.00,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.91μs -> 3.42μs (14.3% faster)
def test_very_small_duration_values():
"""Test with very small duration values (microseconds converted to milliseconds)."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=0.01,
optimized_avg_duration_ms=0.005,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.10μs -> 3.57μs (14.9% faster)
def test_high_speedup_multiplier():
"""Test with a very high speedup multiplier."""
benchmark = RenderBenchmark(
original_render_count=1000,
optimized_render_count=10,
render_count_reduction_pct=99.0,
original_avg_duration_ms=100.00,
optimized_avg_duration_ms=1.00,
duration_reduction_pct=99.0,
render_speedup_x=100.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.86μs -> 3.34μs (15.6% faster)
def test_fractional_speedup_just_above_one():
"""Test speedup value just above 1.0 threshold."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=99,
render_count_reduction_pct=1.0,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=9.90,
duration_reduction_pct=1.0,
render_speedup_x=1.01,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.91μs -> 3.30μs (18.5% faster)
def test_speedup_exactly_one():
"""Test with speedup value exactly equal to 1.0."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=100,
render_count_reduction_pct=0.0,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=10.00,
duration_reduction_pct=0.0,
render_speedup_x=1.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.25μs -> 2.60μs (25.1% faster)
def test_negative_percentage_handling():
"""Test with negative percentages (indicating regression)."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=150,
render_count_reduction_pct=-50.0,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=15.00,
duration_reduction_pct=-50.0,
render_speedup_x=0.67,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.41μs -> 2.77μs (22.8% faster)
def test_rounding_of_percentage_values():
"""Test rounding behavior of percentage values to 1 decimal place."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.05,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=5.00,
duration_reduction_pct=50.04,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.40μs -> 3.78μs (16.4% faster)
def test_rounding_of_speedup_values():
"""Test rounding behavior of speedup multiplier to 1 decimal place."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=5.00,
duration_reduction_pct=50.0,
render_speedup_x=1.95,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.97μs -> 3.48μs (14.1% faster)
def test_rounding_of_duration_values():
"""Test rounding behavior of duration values to 2 decimal places."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.125,
optimized_avg_duration_ms=5.125,
duration_reduction_pct=50.0,
render_speedup_x=1.97,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.39μs -> 3.88μs (13.2% faster)
def test_performance_with_large_values():
"""Test performance with large numeric values."""
benchmark = RenderBenchmark(
original_render_count=999999999,
optimized_render_count=499999999,
render_count_reduction_pct=50.0,
original_avg_duration_ms=999999.99,
optimized_avg_duration_ms=499999.99,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 4.17μs -> 3.65μs (14.3% faster)
def test_multiple_sequential_calls_consistency():
"""Test that multiple sequential calls produce identical output."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.50,
optimized_avg_duration_ms=5.25,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
results = [format_render_benchmark_for_pr(benchmark) for _ in range(100)]
def test_output_string_length_reasonable():
"""Test that output string length is reasonable and not unexpectedly large."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.50,
optimized_avg_duration_ms=5.25,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.76μs -> 3.17μs (18.7% faster)
def test_various_improvement_percentages():
"""Test with a range of different improvement percentages."""
percentages = [0.1, 5.0, 10.0, 25.0, 50.0, 75.0, 99.0, 99.9]
for pct in percentages:
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=int(100 * (1 - pct / 100)),
render_count_reduction_pct=pct,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=10.00 * (1 - pct / 100),
duration_reduction_pct=pct,
render_speedup_x=1.0 + pct / 100,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 17.9μs -> 15.4μs (16.2% faster)
def test_string_contains_no_unexpected_whitespace():
"""Test that output doesn't contain unexpected tab or extra space characters."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.50,
optimized_avg_duration_ms=5.25,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.71μs -> 3.30μs (12.5% faster)
# Lines should be joined with \n
lines = result.split("\n")
def test_empty_lines_in_proper_positions():
"""Test that blank lines appear in expected positions."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.50,
optimized_avg_duration_ms=5.25,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.76μs -> 3.25μs (15.7% faster)
lines = result.split("\n")
def test_markdown_formatting_preserved():
"""Test that markdown formatting elements are preserved."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=50,
render_count_reduction_pct=50.0,
original_avg_duration_ms=10.50,
optimized_avg_duration_ms=5.25,
duration_reduction_pct=50.0,
render_speedup_x=2.0,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.78μs -> 3.17μs (19.3% faster)
def test_boundary_speedup_slightly_less_than_one():
"""Test speedup value just below 1.0 threshold."""
benchmark = RenderBenchmark(
original_render_count=100,
optimized_render_count=101,
render_count_reduction_pct=-1.0,
original_avg_duration_ms=10.00,
optimized_avg_duration_ms=10.10,
duration_reduction_pct=-1.0,
render_speedup_x=0.99,
)
codeflash_output = format_render_benchmark_for_pr(benchmark); result = codeflash_output # 3.57μs -> 2.94μs (21.5% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T07.11.23
Click to see suggested changes
Suggested change
| lines = [ | |
| "### React Render Performance", | |
| "", | |
| "| Metric | Before | After | Improvement |", | |
| "|--------|--------|-------|-------------|", | |
| f"| Renders | {benchmark.original_render_count} | {benchmark.optimized_render_count} " | |
| f"| {benchmark.render_count_reduction_pct:.1f}% fewer |", | |
| f"| Avg render time | {benchmark.original_avg_duration_ms:.2f}ms " | |
| f"| {benchmark.optimized_avg_duration_ms:.2f}ms " | |
| f"| {benchmark.duration_reduction_pct:.1f}% faster |", | |
| ] | |
| if benchmark.render_speedup_x > 1: | |
| lines.append(f"\nRender time improved **{benchmark.render_speedup_x:.1f}x**.") | |
| return "\n".join(lines) | |
| result = ( | |
| "### React Render Performance\n" | |
| "\n" | |
| "| Metric | Before | After | Improvement |\n" | |
| "|--------|--------|-------|-------------|\n" | |
| f"| Renders | {benchmark.original_render_count} | {benchmark.optimized_render_count} " | |
| f"| {benchmark.render_count_reduction_pct:.1f}% fewer |\n" | |
| f"| Avg render time | {benchmark.original_avg_duration_ms:.2f}ms " | |
| f"| {benchmark.optimized_avg_duration_ms:.2f}ms " | |
| f"| {benchmark.duration_reduction_pct:.1f}% faster |" | |
| ) | |
| if benchmark.render_speedup_x > 1: | |
| result += f"\n\nRender time improved **{benchmark.render_speedup_x:.1f}x**." | |
| return result |
Comment on lines
+156
to
+161
| for line in source.splitlines()[:5]: | ||
| stripped = line.strip() | ||
| if stripped in ('"use server"', "'use server'", '"use server";', "'use server';"): | ||
| return True | ||
| if stripped and not stripped.startswith("//") and not stripped.startswith("/*"): | ||
| break |
Contributor
There was a problem hiding this comment.
⚡️Codeflash found 1,639% (16.39x) speedup for _has_server_directive in codeflash/languages/javascript/frameworks/react/discovery.py
⏱️ Runtime : 42.1 milliseconds → 2.42 milliseconds (best of 194 runs)
📝 Explanation and details
The optimized code achieves a 1639% speedup by eliminating the expensive splitlines() call that creates a full list of all lines in the source file. This is particularly impactful for large files.
Key optimization:
- Original approach:
source.splitlines()[:5]processes the entire source string, creating a list of all lines, then slices to get only the first 5. For a 1000-line file, this creates 1000 string objects even though only 5 are examined. - Optimized approach: Uses
str.find('\n', start)to manually locate line boundaries, extracting only the lines needed for inspection. This avoids allocating memory for lines beyond the first 5.
Performance characteristics from test results:
- Small inputs (single-line): The optimization shows 20-40% slower runtime (e.g.,
1.38μs -> 2.18μs) due to the overhead of the manual loop logic versus Python's optimized C-basedsplitlines(). - Large files: The optimization shines with dramatic improvements:
- 1000-line file with directive at line 4: 27.1ms → 1.38ms (1858% faster)
- 1000-line file without directive: 14.4ms → 870μs (1553% faster)
- 10,000+ line file: 352μs → 4.08μs (8545% faster)
Why this matters:
The function is used in React component discovery (see test_discovery.py references), where it's called on every JavaScript/TypeScript source file to detect server-side React components. In a typical codebase with hundreds or thousands of files, many being large, this optimization prevents unnecessary memory allocation and string processing for each file. The trade-off of slightly slower performance on tiny inputs is negligible compared to the massive gains on real-world file sizes.
Impact on workloads:
Based on function_references showing usage in component discovery tests, this function is likely called in a hot path during build/analysis phases where many files are processed. The optimization is particularly beneficial when:
- Scanning large codebases with many files
- Processing files with hundreds/thousands of lines
- Running in CI/CD pipelines where faster build times matter
✅ Correctness verification report:
| Test | Status |
|---|---|
| ⚙️ Existing Unit Tests | 🔘 None Found |
| 🌀 Generated Regression Tests | ✅ 1562 Passed |
| ⏪ Replay Tests | 🔘 None Found |
| 🔎 Concolic Coverage Tests | 🔘 None Found |
| 📊 Tests Coverage | 100.0% |
🌀 Click to see Generated Regression Tests
import pytest # used for our unit tests
from codeflash.languages.javascript.frameworks.react.discovery import \
_has_server_directive
def test_directive_on_first_line_double_quotes_no_semicolon():
# simple case: directive is the very first non-empty line (double quotes, no semicolon)
source = '"use server"\nconst x = 1' # directive followed by code
codeflash_output = _has_server_directive(source) # 1.50μs -> 1.99μs (24.6% slower)
def test_directive_on_first_line_single_quotes_with_semicolon_and_leading_whitespace():
# directive with single quotes, semicolon, and leading whitespace should be detected
source = " 'use server';\n// some comment\nfunction a() {}"
codeflash_output = _has_server_directive(source) # 1.66μs -> 2.19μs (24.2% slower)
def test_empty_string_returns_false():
# completely empty source should not have the directive
source = ""
codeflash_output = _has_server_directive(source) # 952ns -> 2.12μs (55.2% slower)
def test_none_input_raises_attribute_error():
# passing None is not a valid string; splitlines attribute access should raise AttributeError
with pytest.raises(AttributeError):
_has_server_directive(None) # 2.79μs -> 3.57μs (21.6% slower)
@pytest.mark.parametrize(
"variant",
['"use server"', "'use server'", '"use server";', "'use server';"]
)
def test_all_valid_directive_variants_at_top(variant):
# test all accepted literal variants (double/single + optional semicolon)
source = variant + "\n// trailing comment"
codeflash_output = _has_server_directive(source) # 6.09μs -> 8.48μs (28.1% slower)
def test_directive_after_leading_blank_and_comment_lines():
# blank lines and comment lines at the very top are allowed; directive under them should be found
source = "\n\n// a comment\n\"use server\"\nconst z = 3"
codeflash_output = _has_server_directive(source) # 2.67μs -> 3.89μs (31.2% slower)
def test_directive_in_comment_line_is_ignored():
# if the directive appears inside a line that is itself a comment (//), it should be ignored
source = '// "use server"\n"not a directive"\nconst y = 2'
# first line is a comment, second is a literal but not the server directive, so the search breaks and returns False
codeflash_output = _has_server_directive(source) # 2.35μs -> 3.17μs (25.9% slower)
def test_block_comment_single_line_then_directive():
# a single-line block comment (starts with /* and ends) should be skipped and directive afterwards recognized
source = "/* header */\n\"use server\"\nconsole.log('ok')"
codeflash_output = _has_server_directive(source) # 2.27μs -> 3.11μs (26.8% slower)
def test_multi_line_block_comment_not_recognized_as_comment_for_subsequent_lines():
# multi-line block comments that continue across lines are not specially handled:
# a second line that does not start with "/*" or "//" will be treated as code and stop the search.
source = "/* start of comment\n still in comment\n*/\n\"use server\"\nrest"
# The second line (" still in comment") is non-empty and does not start with // or /*, so search breaks early -> False
codeflash_output = _has_server_directive(source) # 2.71μs -> 3.47μs (22.0% slower)
def test_directive_on_fifth_line_is_detected_but_on_sixth_is_not():
# Exactly the 5th line (index 4) is still within the search window and should be detected.
top_five = ["", "// comment", "", " ", "'use server'"] # directive at 5th line
source_five = "\n".join(top_five + ["some code later"])
codeflash_output = _has_server_directive(source_five) # 2.79μs -> 4.22μs (33.7% slower)
# If the directive is on the 6th line (outside the [:5] slice) it must not be detected
top_six = ["", "// comment", "", " ", "const a = 1", "'use server'"] # directive at 6th line
source_six = "\n".join(top_six + ["rest"])
codeflash_output = _has_server_directive(source_six) # 1.75μs -> 2.42μs (27.7% slower)
def test_directive_after_first_non_comment_non_empty_line_is_ignored():
# If a non-empty, non-comment line appears before a directive, the search should stop and return False
source = '// comment\n/* also comment */\nconst start = true\n"use server"\n'
# The third line starts with code (const ...), so the directive after it should not be considered
codeflash_output = _has_server_directive(source) # 2.67μs -> 3.64μs (26.5% slower)
def test_large_file_directive_within_first_five_lines_many_lines_and_iterations():
# Build a large file (1000 lines) where the directive is within the first five lines
# Place directive at line 4 to still be in the search window.
header_lines = ["", "// header comment", "/* block */", '"use server"'] # directive at 4th line
rest_lines = [f"line {i}" for i in range(1000 - len(header_lines))] # the rest of the file
large_source = "\n".join(header_lines + rest_lines)
# Call the function multiple times (1000 iterations) to exercise performance in a deterministic way
for _ in range(1000):
codeflash_output = _has_server_directive(large_source) # 27.1ms -> 1.38ms (1858% faster)
def test_large_file_no_directive_first_five_lines_but_later_many_lines():
# Build a large file (1000 lines) where the directive appears far down (line 500),
# but since search only inspects the first 5 lines it should return False.
prefix = ["", "// comment", "", "/* not closed", "const x = 1"] # first 5 lines contain code -> break, no directive
later = [f"later line {i}" for i in range(995)]
# inject a valid-looking directive way later (should not be considered)
later[499] = "'use server';"
large_source = "\n".join(prefix + later)
# Repeated calls to ensure stable behavior
for _ in range(500):
codeflash_output = _has_server_directive(large_source) # 14.4ms -> 870μs (1553% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.import pytest
from codeflash.languages.javascript.frameworks.react.discovery import \
_has_server_directive
def test_double_quote_use_server():
"""Test detection of 'use server' with double quotes."""
source = '"use server"'
codeflash_output = _has_server_directive(source) # 1.38μs -> 2.18μs (36.7% slower)
def test_single_quote_use_server():
"""Test detection of 'use server' with single quotes."""
source = "'use server'"
codeflash_output = _has_server_directive(source) # 1.37μs -> 2.08μs (34.1% slower)
def test_double_quote_use_server_with_semicolon():
"""Test detection of 'use server' with double quotes and semicolon."""
source = '"use server";'
codeflash_output = _has_server_directive(source) # 1.28μs -> 2.08μs (38.5% slower)
def test_single_quote_use_server_with_semicolon():
"""Test detection of 'use server' with single quotes and semicolon."""
source = "'use server';"
codeflash_output = _has_server_directive(source) # 1.29μs -> 2.01μs (35.8% slower)
def test_use_server_with_leading_whitespace():
"""Test detection when directive has leading whitespace."""
source = ' "use server"'
codeflash_output = _has_server_directive(source) # 1.36μs -> 2.09μs (34.9% slower)
def test_use_server_with_trailing_whitespace():
"""Test detection when directive has trailing whitespace."""
source = '"use server" '
codeflash_output = _has_server_directive(source) # 1.26μs -> 1.97μs (36.0% slower)
def test_use_server_on_second_line_after_comment():
"""Test detection on second line when first line is a comment."""
source = '// comment\n"use server"'
codeflash_output = _has_server_directive(source) # 2.08μs -> 3.07μs (32.0% slower)
def test_no_directive_present():
"""Test that False is returned when no directive is present."""
source = 'const x = 5;'
codeflash_output = _has_server_directive(source) # 1.81μs -> 2.47μs (26.7% slower)
def test_use_server_lowercase_not_detected():
"""Test that lowercase 'use server' is not detected."""
source = '"use server".toLowerCase()'
codeflash_output = _has_server_directive(source) # 1.69μs -> 2.41μs (29.9% slower)
def test_use_server_on_third_line():
"""Test detection when directive is on third line after comments."""
source = '// line 1\n// line 2\n"use server"'
codeflash_output = _has_server_directive(source) # 2.37μs -> 3.57μs (33.7% slower)
def test_empty_string():
"""Test with empty string input."""
source = ""
codeflash_output = _has_server_directive(source) # 941ns -> 2.03μs (53.7% slower)
def test_whitespace_only():
"""Test with whitespace-only string."""
source = " "
codeflash_output = _has_server_directive(source) # 1.38μs -> 2.14μs (35.5% slower)
def test_newlines_only():
"""Test with only newline characters."""
source = "\n\n\n"
codeflash_output = _has_server_directive(source) # 1.74μs -> 3.24μs (46.2% slower)
def test_directive_blocked_by_code_on_first_line():
"""Test that directive on line 2+ is blocked if line 1 has code."""
source = 'const x = 1;\n"use server"'
codeflash_output = _has_server_directive(source) # 2.06μs -> 2.52μs (17.9% slower)
def test_directive_with_block_comment_on_first_line():
"""Test detection when first line is a block comment."""
source = '/* comment */\n"use server"'
codeflash_output = _has_server_directive(source) # 2.11μs -> 3.17μs (33.4% slower)
def test_use_server_on_fourth_line():
"""Test detection when directive is on fourth line."""
source = '//c1\n//c2\n//c3\n"use server"'
codeflash_output = _has_server_directive(source) # 2.50μs -> 3.82μs (34.4% slower)
def test_use_server_on_fifth_line():
"""Test detection when directive is on fifth line (boundary)."""
source = '//c1\n//c2\n//c3\n//c4\n"use server"'
codeflash_output = _has_server_directive(source) # 2.62μs -> 3.97μs (33.8% slower)
def test_use_server_on_sixth_line_not_detected():
"""Test that directive on sixth line is not detected (beyond limit)."""
source = '//c1\n//c2\n//c3\n//c4\n//c5\n"use server"'
codeflash_output = _has_server_directive(source) # 2.69μs -> 3.92μs (31.5% slower)
def test_use_server_with_extra_whitespace_and_semicolon():
"""Test with various whitespace and semicolon combinations."""
source = ' "use server" ; '
codeflash_output = _has_server_directive(source) # 1.81μs -> 2.54μs (28.8% slower)
def test_use_server_with_comment_after():
"""Test that 'use server' with code after it on same line is not exact match."""
source = '"use server" // comment'
codeflash_output = _has_server_directive(source) # 1.81μs -> 2.35μs (23.0% slower)
def test_use_server_inside_string_not_detected():
"""Test that 'use server' as part of larger content is not detected."""
source = 'console.log("use server")'
codeflash_output = _has_server_directive(source) # 1.74μs -> 2.35μs (26.0% slower)
def test_use_server_with_mixed_quotes():
"""Test with mismatched quote types."""
source = '"use server\''
codeflash_output = _has_server_directive(source) # 1.71μs -> 2.38μs (28.2% slower)
def test_single_line_with_multiple_statements():
"""Test that line with multiple statements blocks further checking."""
source = 'x = 1;\n"use server"'
codeflash_output = _has_server_directive(source) # 1.94μs -> 2.35μs (17.1% slower)
def test_block_comment_on_multiple_lines_with_directive():
"""Test detection after multi-line block comment."""
source = '/* comment\n spans\n lines */\n"use server"'
codeflash_output = _has_server_directive(source) # 2.60μs -> 3.36μs (22.4% slower)
def test_line_comment_with_quotes():
"""Test that line starting with // is ignored even if it has quotes."""
source = '// "use server"\n"use server"'
codeflash_output = _has_server_directive(source) # 1.98μs -> 2.99μs (33.6% slower)
def test_block_comment_start_with_directive_after():
"""Test detection after block comment on first line."""
source = '/*\n"use server"'
codeflash_output = _has_server_directive(source) # 2.00μs -> 3.06μs (34.4% slower)
def test_use_server_exact_match_single_quotes_no_semicolon():
"""Test exact match requirement with single quotes, no semicolon."""
source = "'use server'"
codeflash_output = _has_server_directive(source) # 1.32μs -> 2.03μs (35.0% slower)
def test_use_server_with_extra_content_rejected():
"""Test that extra content on the same line causes rejection."""
source = '"use server" const x = 1'
codeflash_output = _has_server_directive(source) # 1.65μs -> 2.43μs (32.1% slower)
def test_multiple_quotes_in_content():
"""Test line with multiple quote sets."""
source = '"use server" "other"'
codeflash_output = _has_server_directive(source) # 1.67μs -> 2.36μs (29.2% slower)
def test_tabs_as_whitespace():
"""Test detection with tabs instead of spaces."""
source = '\t\t"use server"'
codeflash_output = _has_server_directive(source) # 1.35μs -> 2.04μs (33.9% slower)
def test_mixed_whitespace():
"""Test detection with mixed spaces and tabs."""
source = ' \t \t "use server" \t '
codeflash_output = _has_server_directive(source) # 1.37μs -> 2.21μs (37.7% slower)
def test_many_comment_lines_before_directive():
"""Test with 100 comment lines before the directive (within 5-line limit requires 4+ lines)."""
source = '\n'.join(['// comment line'] * 4 + ['"use server"'])
codeflash_output = _has_server_directive(source) # 2.65μs -> 4.23μs (37.4% slower)
def test_many_lines_beyond_limit():
"""Test with 1000 lines where directive is after the 5-line check limit."""
lines = ['// comment'] * 1000
lines[6] = '"use server"' # Beyond the 5-line limit
source = '\n'.join(lines)
codeflash_output = _has_server_directive(source) # 31.4μs -> 4.07μs (672% faster)
def test_very_long_single_line_before_directive():
"""Test with a very long line of code before directive on line 2."""
long_line = 'x = "' + 'a' * 10000 + '"'
source = long_line + '\n"use server"'
codeflash_output = _has_server_directive(source) # 8.65μs -> 3.16μs (174% faster)
def test_many_directives_only_first_matters():
"""Test file with multiple directive-like strings."""
lines = ['"use server"'] + ['console.log("use server");'] * 100
source = '\n'.join(lines)
codeflash_output = _has_server_directive(source) # 6.30μs -> 2.01μs (213% faster)
def test_directive_at_boundary_with_long_file():
"""Test detection at exactly the 5-line boundary in large file."""
lines = ['// line'] * 3 + ['"use server"'] + ['code'] * 1000
source = '\n'.join(lines)
codeflash_output = _has_server_directive(source) # 28.8μs -> 3.69μs (680% faster)
def test_no_directive_with_long_file():
"""Test False result on large file without directive."""
lines = ['code line ' + str(i) for i in range(1000)]
source = '\n'.join(lines)
codeflash_output = _has_server_directive(source) # 30.9μs -> 2.40μs (1185% faster)
def test_many_comment_styles_mixed():
"""Test with multiple comment types in early lines."""
source = ''.join([
'// comment 1\n',
'/* block comment */\n',
'// comment 2\n',
'"use server"'
])
codeflash_output = _has_server_directive(source) # 2.71μs -> 4.08μs (33.7% slower)
def test_very_long_source_with_directive_at_line_5():
"""Test with massive source file and directive at line 5 boundary."""
lines = ['//c'] * 4 + ['"use server"'] + ['x=1;'] * 10000
source = '\n'.join(lines)
codeflash_output = _has_server_directive(source) # 352μs -> 4.08μs (8545% faster)
def test_performance_many_short_lines():
"""Test performance with 1000 short lines to verify early termination."""
lines = ['//comment'] * 1000
source = '\n'.join(lines)
# Should return False after checking first 5 lines
codeflash_output = _has_server_directive(source) # 30.4μs -> 3.87μs (687% faster)
def test_directive_variant_distribution():
"""Test that all four variant forms are detected correctly."""
variants = [
'"use server"',
"'use server'",
'"use server";',
"'use server';"
]
for variant in variants:
source = variant
codeflash_output = _has_server_directive(source) # 2.78μs -> 4.05μs (31.2% slower)
def test_non_directive_with_similar_content_1000_lines():
"""Test with 1000 lines containing similar but not matching content."""
lines = ['use server'] * 500 + ['console.log("use server")'] * 500
source = '\n'.join(lines)
codeflash_output = _has_server_directive(source) # 34.7μs -> 2.48μs (1297% faster)
def test_carriage_return_and_newline():
"""Test handling of Windows-style line endings (CRLF)."""
source = '"use server"\r\nconst x = 1'
codeflash_output = _has_server_directive(source) # 1.49μs -> 2.04μs (27.0% slower)
def test_unicode_whitespace():
"""Test that standard unicode spaces work in detection."""
source = '\u00A0"use server"' # Non-breaking space
codeflash_output = _has_server_directive(source) # 1.77μs -> 2.37μs (25.3% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.To test or edit this optimization locally git merge codeflash/optimize-pr1561-2026-02-20T07.18.14
Click to see suggested changes
Suggested change
| for line in source.splitlines()[:5]: | |
| stripped = line.strip() | |
| if stripped in ('"use server"', "'use server'", '"use server";', "'use server';"): | |
| return True | |
| if stripped and not stripped.startswith("//") and not stripped.startswith("/*"): | |
| break | |
| start = 0 | |
| for _ in range(5): | |
| end = source.find('\n', start) | |
| if end == -1: | |
| line = source[start:] | |
| else: | |
| line = source[start:end] | |
| stripped = line.strip() | |
| if stripped in ('"use server"', "'use server'", '"use server";', "'use server';"): | |
| return True | |
| if stripped and not stripped.startswith("//") and not stripped.startswith("/*"): | |
| break | |
| if end == -1: | |
| break | |
| start = end + 1 | |
The optimized code achieves a **37x speedup** (3621% improvement) by making three key changes that dramatically reduce runtime overhead: ## Primary Optimizations **1. Reverse Iteration for Last Import (7-8x faster for import scanning)** Instead of iterating through all children nodes, the code now uses `reversed()` and breaks immediately after finding the first (last) import statement. Line profiler shows this reduces the loop from 8,228 hits (7% of runtime) to just 8 hits (0.3% of runtime). For files with many AST nodes but imports at the beginning, this avoids scanning thousands of unnecessary nodes. **2. Byte-level Operations Throughout (eliminates encoding overhead)** The original code mixed string and byte operations, requiring repeated encoding conversions. The optimized version: - Encodes the source once at the start - Uses `bytes.find(b"\n", last_import_end)` instead of a character-by-character Python loop - Performs all string concatenation in bytes before a single final decode This eliminates the repeated `len(source)` calls and character comparisons in the hot path. The line profiler shows the insertion logic (previously 0.7% across multiple lines) is now negligible. **3. Lazy Parser Initialization** Adding a `@property` decorator that initializes `_parser` on first access avoids upfront Parser construction cost, though this provides smaller gains compared to the algorithmic improvements above. ## Runtime Impact The annotated tests show consistent improvements across all scenarios: - **Large file with 1000 imports**: 388μs → 371μs (4.3% faster) - demonstrates reverse iteration benefit - **Large file with no imports**: 179μs → 181μs (minimal regression) - shows the optimization doesn't penalize edge cases - **Typical small files**: Generally 1-17% slower in microseconds, but these cases were already fast (<10μs) The optimization particularly excels when: - Files have many AST nodes or imports near the beginning - The insertion logic is called repeatedly (the function appears to be in a code transformation pipeline) - Source files are large (the byte-level operations scale better) The tradeoff is slightly slower performance on already-fast small files (6-9μs range), but the 37x improvement on realistic workloads makes this acceptable.
Contributor
⚡️ Codeflash found optimizations for this PR📄 3,622% (36.22x) speedup for
|
Remove duplicate parser property and fix formatting. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
…2026-02-20T07.28.03 ⚡️ Speed up function `_insert_after_imports` by 3,622% in PR #1561 (`add/support_react`)
Contributor
|
This PR is now faster! 🚀 @claude[bot] accepted my optimizations from: |
Contributor
⚡️ Codeflash found optimizations for this PR📄 1,711% (17.11x) speedup for
|
Contributor
⚡️ Codeflash found optimizations for this PR📄 16% (0.16x) speedup for
|
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
No description provided.