⚡️ Speed up function is_inside_string by 58% in PR #1318 (fix/js-jest30-loop-runner)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1318

If you approve this dependent PR, these changes will be merged into the original PR branch fix/js-jest30-loop-runner.

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

---

📄 58% (0.58x) speedup for is_inside_string in codeflash/languages/javascript/instrument.py

⏱️ Runtime : 991 microseconds → 627 microseconds (best of 140 runs)

📝 Explanation and details

The optimized code achieves a 58% runtime improvement (from 991μs to 627μs) by replacing character-by-character iteration with a regex-based fast-path that jumps directly to the next "special" character (quotes or backslashes).

Key optimization:
Instead of examining every character in the code string with Python-level operations (code[i], char in "\"'"), the optimized version uses a precompiled regex pattern (_SPECIAL_RE`) to scan for the next relevant character in C code (via the regex engine). This dramatically reduces Python interpreter overhead.

Why this works:

• The original code spent ~16% of time in the while i < pos loop condition checks and ~17.8% indexing into the string (char = code[i])
• The optimized code reduces loop iterations from 21,270 to just 1,859 by skipping over long stretches of non-special characters
• For long strings without quotes/backslashes, search() can scan hundreds/thousands of characters in a single C-level operation instead of iterating in Python

Performance characteristics based on test results:

• Small strings (< 20 chars): Actually 50-70% slower due to regex overhead - the setup cost of calling search() outweighs the benefit
• Large strings (> 1000 chars): Massive speedups of 500-1300% - the fast-path shines when scanning long runs of normal code
• Medium strings (20-1000 chars): Mixed results - slight slowdowns to moderate gains depending on quote density

Impact on workloads:
The function is called from test instrumentation code (as shown in test_javascript_instrumentation.py), where it checks if positions in JavaScript code are inside string literals. In real-world instrumentation scenarios with typical JavaScript files (hundreds to thousands of characters), this optimization will significantly reduce overhead when instrumenting or analyzing code, especially when checking many positions in files with long non-string sections.

The trade-off of slower performance on very small strings is acceptable because the absolute time difference (nanoseconds vs microseconds) is negligible, while the gains on realistically-sized code files are substantial.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 54 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.instrument import is_inside_string

def test_position_before_string_starts():
    """Test that position before any string returns False."""
    codeflash_output = is_inside_string('x = "hello"', 0); result = codeflash_output # 449ns -> 1.05μs (57.4% slower)

def test_position_at_first_character_after_quote():
    """Test position immediately after opening quote is inside string."""
    codeflash_output = is_inside_string('x = "hello"', 5); result = codeflash_output # 1.13μs -> 2.70μs (58.1% slower)

def test_position_inside_double_quoted_string():
    """Test that position in middle of double-quoted string returns True."""
    codeflash_output = is_inside_string('"hello world"', 7); result = codeflash_output # 1.37μs -> 2.74μs (50.1% slower)

def test_position_inside_single_quoted_string():
    """Test that position in middle of single-quoted string returns True."""
    codeflash_output = is_inside_string("'hello world'", 7); result = codeflash_output # 1.38μs -> 2.71μs (49.1% slower)

def test_position_inside_backtick_string():
    """Test that position in middle of backtick (template literal) returns True."""
    codeflash_output = is_inside_string('`hello world`', 7); result = codeflash_output # 1.31μs -> 2.61μs (49.9% slower)

def test_position_after_string_ends():
    """Test that position after string closes returns False."""
    codeflash_output = is_inside_string('"hello"x', 7); result = codeflash_output # 1.41μs -> 3.17μs (55.6% slower)

def test_position_outside_multiple_strings():
    """Test position between two separate strings returns False."""
    codeflash_output = is_inside_string('"first" x "second"', 8); result = codeflash_output # 1.55μs -> 3.29μs (52.9% slower)

def test_escaped_quote_does_not_end_string():
    """Test that escaped quote doesn't close the string."""
    codeflash_output = is_inside_string(r'"hello\"world"', 8); result = codeflash_output # 1.47μs -> 3.01μs (51.2% slower)

def test_escaped_quote_at_position():
    """Test position at escaped quote character is still inside string."""
    codeflash_output = is_inside_string(r'"hello\"world"', 7); result = codeflash_output # 1.39μs -> 2.89μs (51.7% slower)

def test_escaped_quote_double_escaped():
    """Test double-escaped quote doesn't prevent string close."""
    codeflash_output = is_inside_string(r'"hello\\"', 8); result = codeflash_output # 1.41μs -> 2.98μs (52.8% slower)

def test_empty_string_code():
    """Test with empty code string."""
    codeflash_output = is_inside_string('', 0); result = codeflash_output # 399ns -> 906ns (56.0% slower)

def test_position_zero():
    """Test with position at zero."""
    codeflash_output = is_inside_string('x = 5', 0); result = codeflash_output # 384ns -> 870ns (55.9% slower)

def test_position_at_string_quote():
    """Test position exactly at the opening quote."""
    codeflash_output = is_inside_string('"hello"', 0); result = codeflash_output # 385ns -> 916ns (58.0% slower)

def test_position_at_closing_quote():
    """Test position exactly at the closing quote."""
    codeflash_output = is_inside_string('"hello"', 6); result = codeflash_output # 1.32μs -> 2.76μs (52.0% slower)

def test_single_character_string():
    """Test with single character inside string."""
    codeflash_output = is_inside_string('"a"', 1); result = codeflash_output # 724ns -> 2.36μs (69.4% slower)

def test_nested_single_quotes_inside_double_quotes():
    """Test single quotes inside double-quoted string don't affect parsing."""
    codeflash_output = is_inside_string('"it\'s"', 4); result = codeflash_output # 1.09μs -> 3.11μs (65.0% slower)

def test_nested_double_quotes_inside_single_quotes():
    """Test double quotes inside single-quoted string don't affect parsing."""
    codeflash_output = is_inside_string('\'say "hi"\'', 6); result = codeflash_output # 1.30μs -> 3.02μs (57.0% slower)

def test_nested_backticks_inside_double_quotes():
    """Test backticks inside double-quoted string don't affect parsing."""
    codeflash_output = is_inside_string('"`test`"', 5); result = codeflash_output # 1.17μs -> 3.12μs (62.5% slower)

def test_consecutive_strings():
    """Test position between consecutive strings."""
    codeflash_output = is_inside_string('"first""second"', 6); result = codeflash_output # 1.24μs -> 2.46μs (49.7% slower)

def test_string_with_spaces_only():
    """Test inside string containing only spaces."""
    codeflash_output = is_inside_string('"   "', 2); result = codeflash_output # 871ns -> 2.39μs (63.6% slower)

def test_string_with_special_characters():
    """Test inside string with special characters."""
    codeflash_output = is_inside_string('"!@#$%^&*()"', 6); result = codeflash_output # 1.23μs -> 2.44μs (49.7% slower)

def test_string_with_newline_escape():
    """Test inside string with newline escape sequence."""
    codeflash_output = is_inside_string('"hello\\nworld"', 7); result = codeflash_output # 1.47μs -> 2.98μs (50.7% slower)

def test_string_with_tab_escape():
    """Test inside string with tab escape sequence."""
    codeflash_output = is_inside_string('"hello\\tworld"', 7); result = codeflash_output # 1.39μs -> 2.93μs (52.6% slower)

def test_multiple_escaped_quotes():
    """Test string with multiple consecutive escaped quotes."""
    codeflash_output = is_inside_string(r'"hello\"\""world"', 10); result = codeflash_output # 1.52μs -> 3.22μs (52.8% slower)

def test_position_equals_length():
    """Test position at end of code (equals length)."""
    code = '"hello"'
    codeflash_output = is_inside_string(code, len(code)); result = codeflash_output # 1.33μs -> 3.04μs (56.3% slower)

def test_string_with_backslash_before_non_quote():
    """Test backslash followed by non-quote character."""
    codeflash_output = is_inside_string(r'"hello\nworld"', 8); result = codeflash_output # 1.45μs -> 2.93μs (50.5% slower)

def test_code_with_unmatched_opening_quote():
    """Test code with unclosed string literal."""
    codeflash_output = is_inside_string('"hello', 3); result = codeflash_output # 986ns -> 2.45μs (59.8% slower)

def test_code_with_unmatched_quote_at_position():
    """Test position at or beyond unclosed string."""
    codeflash_output = is_inside_string('"hello', 6); result = codeflash_output # 1.19μs -> 2.54μs (53.0% slower)

def test_three_consecutive_backslashes_before_quote():
    """Test odd number of backslashes before quote (quote is escaped)."""
    codeflash_output = is_inside_string(r'"hello\\\\"', 9); result = codeflash_output # 1.54μs -> 3.19μs (51.9% slower)

def test_single_backslash_at_string_end():
    """Test single backslash followed by quote at string boundary."""
    codeflash_output = is_inside_string(r'"hello\\"', 7); result = codeflash_output # 1.37μs -> 2.92μs (53.0% slower)

def test_position_in_middle_of_escaped_character():
    """Test skipping over escaped character properly."""
    # After backslash-escaped quote, position should skip the pair
    codeflash_output = is_inside_string(r'"test\"value"', 6); result = codeflash_output # 1.31μs -> 2.91μs (55.0% slower)

def test_empty_string_between_quotes():
    """Test empty string literal."""
    codeflash_output = is_inside_string('""', 1); result = codeflash_output # 664ns -> 2.26μs (70.7% slower)

def test_single_quote_empty_string():
    """Test empty string with single quotes."""
    codeflash_output = is_inside_string("''", 1); result = codeflash_output # 706ns -> 2.30μs (69.3% slower)

def test_backtick_empty_string():
    """Test empty template literal."""
    codeflash_output = is_inside_string('``', 1); result = codeflash_output # 717ns -> 2.23μs (67.8% slower)

def test_all_quote_types_in_sequence():
    """Test code with all three quote types."""
    code = '"first" \'second\' `third`'
    # Position in double-quoted string
    codeflash_output = is_inside_string(code, 3) # 983ns -> 2.54μs (61.3% slower)
    # Position in single-quoted string
    codeflash_output = is_inside_string(code, 13) # 1.46μs -> 2.39μs (38.8% slower)
    # Position in backtick string
    codeflash_output = is_inside_string(code, 23) # 1.67μs -> 2.21μs (24.7% slower)

def test_large_string_position_inside():
    """Test with large string and position inside."""
    large_string = '"' + 'x' * 1000 + '"'
    codeflash_output = is_inside_string(large_string, 500); result = codeflash_output # 28.6μs -> 4.53μs (533% faster)

def test_large_string_position_outside():
    """Test with large string and position outside."""
    large_string = '"' + 'x' * 1000 + '" y'
    codeflash_output = is_inside_string(large_string, 1002); result = codeflash_output # 57.4μs -> 7.09μs (709% faster)

def test_many_strings_position_in_middle_string():
    """Test code with many consecutive strings, check middle string."""
    # Create 100 strings concatenated together
    code = ' '.join([f'"{i}"' for i in range(100)])
    # Find position in string for number 50
    pos = code.index('"50"') + 1
    codeflash_output = is_inside_string(code, pos); result = codeflash_output # 14.3μs -> 28.6μs (50.1% slower)

def test_many_strings_position_between_strings():
    """Test code with many strings, check position between them."""
    code = ' '.join([f'"{i}"' for i in range(100)])
    # Find space between first two strings
    pos = code.index('" "')
    codeflash_output = is_inside_string(code, pos); result = codeflash_output # 892ns -> 2.48μs (64.1% slower)

def test_long_code_with_escaped_quotes_throughput():
    """Test long code with many escaped quotes for performance."""
    # Create code with alternating escaped quotes
    code = '"' + (r'\" ' * 500) + '"'
    codeflash_output = is_inside_string(code, 1000); result = codeflash_output # 47.8μs -> 88.9μs (46.2% slower)

def test_position_far_into_long_string():
    """Test checking very far into a long string."""
    large_code = '"' + ('a' * 10000) + '"'
    codeflash_output = is_inside_string(large_code, 9999); result = codeflash_output # 570μs -> 39.9μs (1331% faster)

def test_many_unescaped_quotes_in_sequence():
    """Test code with many separate single-character strings."""
    # Create: "a" "b" "c" ... for many characters
    code = ' '.join([f'"{chr(97 + i)}"' for i in range(100)])
    # Check various positions
    codeflash_output = is_inside_string(code, 1) # 693ns -> 2.40μs (71.2% slower)
    codeflash_output = is_inside_string(code, 10) # 1.36μs -> 2.84μs (52.2% slower)
    codeflash_output = is_inside_string(code, len(code) - 2) # 22.9μs -> 52.9μs (56.7% slower)

def test_mixed_quotes_large_code():
    """Test large code with mixed quote types."""
    code = ''
    for i in range(200):
        if i % 3 == 0:
            code += f'"string{i}" '
        elif i % 3 == 1:
            code += f"'string{i}' "
        else:
            code += f'`string{i}` '
    
    # Check position in middle of code
    mid_pos = len(code) // 2
    codeflash_output = is_inside_string(code, mid_pos); result = codeflash_output # 71.0μs -> 59.7μs (18.8% faster)

def test_many_escaped_sequences_throughput():
    """Test code with many different escape sequences."""
    # Create string with various escaped characters
    escapes = [r'\"', r"\'", r'\n', r'\t', r'\r', r'\\']
    code = '"' + ''.join(escapes * 150) + '"'
    codeflash_output = is_inside_string(code, 500); result = codeflash_output # 20.2μs -> 64.9μs (68.8% slower)

def test_alternating_string_and_code_large_scale():
    """Test large code alternating between strings and code."""
    code = ''
    for i in range(500):
        code += f'var{i}="value{i}";'
    
    # Find a position inside one of the strings
    pos = code.index('"value') + 3
    codeflash_output = is_inside_string(code, pos); result = codeflash_output # 1.40μs -> 2.63μs (46.9% slower)
    
    # Find position in semicolon (outside string)
    pos = code.index(';')
    codeflash_output = is_inside_string(code, pos); result = codeflash_output # 1.28μs -> 1.82μs (29.6% slower)

def test_deeply_nested_quotes_patterns():
    """Test code with deeply nested quote patterns."""
    # Single quotes inside double quotes, many times
    code = '"' + ("'" * 100) + '"' + ("'" + '"' * 100 + "'") * 50
    codeflash_output = is_inside_string(code, 50); result = codeflash_output # 3.51μs -> 14.6μs (75.9% slower)

def test_performance_with_long_escape_sequence():
    """Test performance with very long escape sequence patterns."""
    # String with repeated escape patterns
    code = '"' + (r'\u0041' * 500) + '"'
    codeflash_output = is_inside_string(code, 1000); result = codeflash_output # 53.3μs -> 46.5μs (14.8% faster)

def test_repeated_quote_pairs_large_scale():
    """Test with many repeated quote pairs."""
    # Create 500 string pairs
    code = ''.join([f'"{i}"{i}' for i in range(500)])
    
    # Position should be inside string for the quoted numbers
    codeflash_output = is_inside_string(code, code.index('"100"') + 1); result = codeflash_output # 34.8μs -> 54.1μs (35.7% slower)

def test_mixed_escaped_and_unescaped_quotes():
    """Test string with mix of escaped and unescaped quotes in patterns."""
    # String containing both escaped quotes and unescaped nested quotes
    code = '"start' + (r'\" "' * 200) + 'end"'
    codeflash_output = is_inside_string(code, 300); result = codeflash_output # 18.3μs -> 58.8μs (68.9% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1318-2026-02-12T16.29.21 and push.

[claude]

PR Review Summary

Prek Checks

Passed after auto-fix. Ruff format fixed 2 extra blank lines in codeflash/languages/javascript/instrument.py. Fix committed and pushed.

Mypy Checks

All 5 mypy errors found are pre-existing on main (missing re.Match type parameters and import-untyped for code_position). No new type errors introduced by this PR.

Code Review

No critical issues found. The is_inside_string optimization is semantically equivalent to the original:

• Uses precompiled regex to skip non-special characters in bulk instead of iterating character-by-character
• All state transitions (entering/exiting strings, escape handling) are preserved exactly
• Edge cases (empty strings, backslash at end, pos at boundaries) behave identically
• The pos > len(code) guard raises IndexError earlier than the original (an improvement)

Note: This PR is auto-generated by codeflash-ai and targets the feature branch fix/js-jest30-loop-runner, not main. The only file changed by this PR is instrument.py.

Test Coverage

File	PR Branch	Main Branch	Change
codeflash/languages/javascript/instrument.py	72%	69%	+3%
Overall Project	79%	78%	+1%

Coverage analysis:

• The optimized is_inside_string function (lines 60-119) is well covered -- only line 82 (IndexError for pos > len(code)) is uncovered
• The new _parse_bracket_standalone_call method (lines 375-420) is not covered by tests -- this appears to be new bracket notation support from the base branch, not from this optimization PR
• Overall coverage improved by +3% for the file and +1% for the project

9 pre-existing test failures in tests/test_tracer.py (unrelated to this PR, also fail on main).

---

Last updated: 2026-02-12

[codeflash-ai]

This PR has been automatically closed because the original PR #1318 by mohammedahmed18 was closed.