⚡️ Speed up function ensure_vitest_imports by 11% in PR #1289 (fix/js-module-detection)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1289

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

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

---

📄 11% (0.11x) speedup for ensure_vitest_imports in codeflash/languages/javascript/module_system.py

⏱️ Runtime : 722 microseconds → 652 microseconds (best of 153 runs)

📝 Explanation and details

This optimization achieves a 10% runtime improvement by eliminating redundant string scanning operations.

Key Optimization

Combined duplicate passes over test_globals: The original code performed two separate passes checking if test globals appear in the code:

1. First pass: needs_import = any(...) to determine if any global is present
2. Second pass: used_globals = [g for g in test_globals if ...] to collect which globals are present

The optimized version merges these into a single pass that directly builds the used_globals list, eliminating the needs_import variable entirely. This cuts the number of substring searches (e.g., f"{g}(" in code) roughly in half.

Why This Speeds Up Execution

In Python, string containment checks using the in operator are O(n×m) operations where n is the length of the haystack and m is the length of the needle. With 9 test globals and potentially large code strings, scanning twice through the code for each global was a significant bottleneck. The line profiler confirms this:

• Original: Lines checking needs_import and used_globals consumed 19.8% of runtime (8.6% + 11.2%)
• Optimized: Single used_globals check consumes 15.9% of runtime

Test Case Performance

The optimization shows particularly strong gains on test cases that:

• Use multiple test globals (16-43% faster on individual global tests)
• Have larger code strings with many test cases (up to 37% faster on test_vitest_adds_expect_import)
• Process files with complex nesting and mixed content (15-27% improvements)

Early-exit paths (non-vitest frameworks, existing imports, no globals needed) remain fast since they bypass the optimization entirely, showing minimal overhead changes (0-3%).

This is a clean, focused optimization that reduces algorithmic complexity without changing behavior or code structure, making it safe to merge.

✅ 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	96.9%

🌀 Click to see Generated Regression Tests

from __future__ import annotations

import logging
import logging as _logging

# imports
import pytest  # used for our unit tests
from codeflash.languages.javascript.module_system import ensure_vitest_imports

def test_non_vitest_framework_returns_unchanged():
    # If test framework isn't 'vitest', the code must be returned unchanged.
    src = "describe('x', () => { test('y', () => {}); });"
    codeflash_output = ensure_vitest_imports(src, test_framework="jest"); res = codeflash_output # 801ns -> 822ns (2.55% slower)

@pytest.mark.parametrize("quote", ["'", '"'])
def test_existing_vitest_import_detected_and_not_duplicated(quote):
    # If code already imports from vitest using single or double quotes, nothing changes.
    src = f"import {{ describe }} from {quote}vitest{quote};\n\ndescribe('ok', () => {{}});"
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 1.95μs -> 1.88μs (3.77% faster)

def test_add_import_at_top_after_leading_comments_and_blank_lines():
    # Comments and blank lines should remain on top; import should be inserted after them.
    src_lines = [
        "// leading comment",
        "",
        "/* block comment start */",
        "/* block comment end */",
        "",
        "describe('top', () => {",
        "  test('a', () => {});",
        "});",
    ]
    src = "\n".join(src_lines)
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 11.6μs -> 10.1μs (14.2% faster)
    # Expect import of describe and test at the first non-comment location
    expected_import = "import { describe, test } from 'vitest';"

def test_insert_after_last_import_statement():
    # When there are existing ES module imports, the vitest import should be inserted after them.
    src_lines = [
        "import fs from 'fs';",
        "import path from 'path';",
        "console.log('something');",
        "describe('afterImports', () => { test('a', () => {}); });",
    ]
    src = "\n".join(src_lines)
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 10.8μs -> 9.60μs (12.8% faster)
    expected_import = "import { describe, test } from 'vitest';"
    # Split to lines to assert ordering: import lines, then our import, then console.log
    lines = res.split("\n")

def test_handles_whitespace_before_parentheses_variants():
    # The function looks for both 'it(' and 'it (' patterns. Ensure both are recognized.
    src = "it ('works', () => {});\nbeforeEach(() => {});\nexpect(true).toBeTruthy();"
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 10.1μs -> 8.23μs (22.5% faster)
    # used_globals are ordered according to the internal test_globals list,
    # not the order they appear in the file.
    # test_globals = ["describe","test","it","expect","vi","beforeEach",...]
    # 'it' and 'beforeEach' and 'expect' are present -> import should include describe? No if not used.
    expected_import = "import { it, expect, beforeEach } from 'vitest';"

def test_no_change_when_no_test_globals_present():
    # If none of the target globals appear, function should not add an import.
    src = "function helper() { return 42; }\nconst x = helper();"
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 4.09μs -> 3.96μs (3.28% faster)

def test_commonjs_require_lines_are_skipped_and_import_inserted_before_first_non_import_line():
    # Lines beginning with 'const ' (require) are treated like imports for insertion logic.
    src_lines = [
        "const fs = require('fs');",
        "const mymod = require('./m');",
        "/* comment */",
        "describe('cjs', () => { test('1', () => {}); });",
    ]
    src = "\n".join(src_lines)
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 10.8μs -> 9.49μs (13.8% faster)
    expected_import = "import { describe, test } from 'vitest';"
    # Find describe line index and ensure the import is immediately before it
    lines = res.split("\n")
    describe_index = next(i for i, ln in enumerate(lines) if ln.strip().startswith("describe"))

def test_detects_globals_in_string_literals_and_still_inserts_import():
    # The implementation performs a substring check and will detect patterns inside strings.
    # This test documents that behavior: a string containing "describe(" triggers import insertion.
    src = "const s = 'not a call: describe(';"
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 8.07μs -> 6.92μs (16.6% faster)
    # Because "describe(" exists in the string, the function will decide an import is needed.
    expected_import_line = "import { describe } from 'vitest';"

def test_import_order_matches_internal_test_globals_list():
    # Even if the occurrences are out-of-order, the import order follows the internal test_globals order.
    # Provide usage in reverse order: afterAll, beforeAll, vi, expect, it
    src = "\n".join([
        "afterAll(() => {});",
        "beforeAll(() => {});",
        "vi('spy');",
        "expect(1).toBe(1);",
        "it('x', () => {});",
    ])
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 9.83μs -> 8.09μs (21.6% faster)
    # Internal order: ["describe","test","it","expect","vi","beforeEach","afterEach","beforeAll","afterAll"]
    expected_order = ["it", "expect", "vi", "beforeAll", "afterAll"]
    # Build expected import string following that internal order
    expected_import = "import { it, expect, vi, beforeAll, afterAll } from 'vitest';"

def test_large_scale_insertion_with_many_lines():
    # Build a reasonably large input (well under the 1000-element constraint).
    # Start with a few imports and then many filler lines, and finally several test calls.
    pre_imports = [
        "import alpha from 'alpha';",
        "import beta from 'beta';",
        "import gamma from 'gamma';",
    ]
    # Create 300 filler lines to simulate a large file (still < 1000)
    filler_lines = [f"// filler line {i}" for i in range(300)]
    # Add multiple test usages spread across the file
    test_lines = [
        "console.log('mid');",
        "test('large-1', () => {});",
        "/* some block */",
        "test('large-2', () => {});",
        "it('large-3', () => {});",
    ]
    src_lines = pre_imports + filler_lines + test_lines
    src = "\n".join(src_lines)
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); res = codeflash_output # 137μs -> 128μs (6.79% faster)
    # The import should be added exactly once and immediately after the last ES import
    expected_import = "import { test, it } from 'vitest';"
    # Ensure no other unexpected vitest imports are present
    # Check ordering: after gamma import (last import) the next non-empty non-comment line should be our import
    lines = res.split("\n")
    last_import_index = max(i for i, ln in enumerate(lines) if ln.strip().startswith("import ") and "from " in ln)
    # Ensure that all original filler and test lines still appear somewhere after the inserted import
    for tl in test_lines:
        pass

def test_idempotent_on_second_call():
    # Applying the function twice should not change the result the second time (no duplicate imports).
    src = "describe('idemp', () => { test('a', () => {}); });"
    codeflash_output = ensure_vitest_imports(src, test_framework="vitest"); first = codeflash_output # 8.44μs -> 7.40μs (13.9% faster)
    codeflash_output = ensure_vitest_imports(first, test_framework="vitest"); second = codeflash_output # 591ns -> 591ns (0.000% 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.module_system import ensure_vitest_imports

def test_non_vitest_framework_returns_unchanged():
    """Test that code is returned unchanged when test_framework is not 'vitest'."""
    code = "describe('test', () => { test('works', () => {}); });"
    codeflash_output = ensure_vitest_imports(code, "jest"); result = codeflash_output # 460ns -> 461ns (0.217% slower)
    
    codeflash_output = ensure_vitest_imports(code, "mocha"); result = codeflash_output # 241ns -> 221ns (9.05% faster)

def test_vitest_with_existing_import_single_quotes():
    """Test that code with existing vitest import (single quotes) is returned unchanged."""
    code = "import { describe, test } from 'vitest';\ndescribe('test', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 781ns -> 781ns (0.000% faster)

def test_vitest_with_existing_import_double_quotes():
    """Test that code with existing vitest import (double quotes) is returned unchanged."""
    code = 'import { describe, test } from "vitest";\ndescribe("test", () => {});'
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 861ns -> 831ns (3.61% faster)

def test_vitest_with_no_test_globals_returns_unchanged():
    """Test that code with no test globals is returned unchanged."""
    code = "const x = 5;\nconst y = 10;"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.72μs -> 3.40μs (9.45% faster)

def test_vitest_adds_describe_import():
    """Test that describe() function triggers import addition."""
    code = "describe('test', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.46μs -> 7.14μs (18.4% faster)

def test_vitest_adds_test_import():
    """Test that test() function triggers import addition."""
    code = "test('works', () => { expect(true).toBe(true); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.88μs -> 7.02μs (26.4% faster)

def test_vitest_adds_it_import():
    """Test that it() function triggers import addition."""
    code = "it('works', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.31μs -> 6.51μs (27.5% faster)

def test_vitest_adds_expect_import():
    """Test that expect() function triggers import addition."""
    code = "expect(5).toBe(5);"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.97μs -> 6.54μs (37.1% faster)

def test_vitest_adds_vi_import():
    """Test that vi() function triggers import addition."""
    code = "vi.mock('./module');"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.64μs -> 3.28μs (11.0% faster)

def test_vitest_adds_beforeEach_import():
    """Test that beforeEach() function triggers import addition."""
    code = "beforeEach(() => { console.log('setup'); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.50μs -> 7.09μs (33.9% faster)

def test_vitest_adds_afterEach_import():
    """Test that afterEach() function triggers import addition."""
    code = "afterEach(() => { console.log('cleanup'); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.97μs -> 6.86μs (30.7% faster)

def test_vitest_adds_beforeAll_import():
    """Test that beforeAll() function triggers import addition."""
    code = "beforeAll(() => { console.log('setup all'); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.34μs -> 6.50μs (43.6% faster)

def test_vitest_adds_afterAll_import():
    """Test that afterAll() function triggers import addition."""
    code = "afterAll(() => { console.log('cleanup all'); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.64μs -> 6.71μs (43.6% faster)

def test_multiple_test_globals_combined():
    """Test that multiple test globals are collected into one import statement."""
    code = "describe('suite', () => { test('case', () => { expect(true).toBe(true); }); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.40μs -> 7.20μs (16.6% faster)

def test_import_inserted_at_beginning():
    """Test that import is inserted at the beginning of the file."""
    code = "describe('test', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 7.79μs -> 6.39μs (21.9% faster)
    lines = result.split("\n")

def test_import_inserted_after_existing_imports():
    """Test that vitest import is inserted after existing imports."""
    code = "import React from 'react';\ndescribe('test', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.27μs -> 7.96μs (16.4% faster)
    lines = result.split("\n")

def test_space_before_parenthesis_in_function_call():
    """Test that function calls with space before parenthesis are detected."""
    code = "describe ('test', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.15μs -> 6.57μs (24.1% faster)

def test_empty_code_string():
    """Test behavior with empty code string."""
    codeflash_output = ensure_vitest_imports("", "vitest"); result = codeflash_output # 2.90μs -> 2.38μs (21.5% faster)

def test_code_with_only_comments():
    """Test code containing only comments."""
    code = "// This is a comment\n/* Multi-line\ncomment */"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.80μs -> 3.42μs (11.2% faster)

def test_code_with_leading_comments():
    """Test that imports are inserted after leading comments."""
    code = "// Comment\ndescribe('test', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.57μs -> 7.48μs (14.5% faster)
    lines = result.split("\n")

def test_function_name_as_string_not_imported():
    """Test that function names inside strings are not triggered."""
    code = "console.log('describe and test are functions');"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.76μs -> 3.46μs (8.71% faster)

def test_function_name_in_variable_name():
    """Test that function names as part of other identifiers don't trigger import."""
    code = "const my_describe = 5;"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.54μs -> 3.23μs (9.64% faster)

def test_describe_without_parenthesis_not_imported():
    """Test that bare function names without parenthesis are not imported."""
    code = "const x = describe;"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.45μs -> 3.06μs (12.8% faster)

def test_multiline_function_call():
    """Test detection of function calls spanning multiple lines."""
    code = """describe(
    'test',
    () => {}
);"""
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.18μs -> 7.76μs (18.2% faster)

def test_nested_function_calls():
    """Test detection of nested function calls."""
    code = "describe('outer', () => { describe('inner', () => { test('case', () => {}); }); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.76μs -> 7.49μs (16.8% faster)

def test_case_sensitivity_describe_lowercase():
    """Test that only exact case matches are detected (describe, not Describe)."""
    code = "Describe('test', () => {});"  # Capital D
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.75μs -> 3.42μs (9.66% faster)

def test_mixed_quotes_in_code():
    """Test code that already uses both single and double quotes."""
    code = '''describe("test", () => {
  test('case', () => {
    expect(5).toBe(5);
  });
});'''
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.52μs -> 8.40μs (13.2% faster)

def test_windows_line_endings():
    """Test code with Windows line endings (CRLF)."""
    code = "describe('test', () => {});\r\ntest('case', () => {});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.48μs -> 7.36μs (15.1% faster)

def test_tabs_and_mixed_whitespace():
    """Test code with tabs and mixed whitespace."""
    code = "\tdescribe('test', () => {\n\t\ttest('case', () => {});\n\t});"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.82μs -> 7.62μs (15.6% faster)

def test_code_with_only_whitespace():
    """Test code containing only whitespace."""
    code = "   \n\t\n   "
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 3.19μs -> 2.83μs (13.1% faster)

def test_import_with_existing_non_vitest_imports():
    """Test that vitest import is added correctly alongside other imports."""
    code = """import axios from 'axios';
import { useState } from 'react';
describe('test', () => {});"""
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.95μs -> 8.77μs (13.5% faster)
    lines = result.split("\n")
    # Should have vitest import after other imports
    import_lines = [l for l in lines if "import" in l and "from" in l]

def test_function_names_in_comments_not_imported():
    """Test that function names mentioned in comments don't trigger import."""
    code = """// describe and test are vitest functions
// This code doesn't use them
const x = 5;"""
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 4.02μs -> 3.60μs (11.7% faster)

def test_special_characters_in_code():
    """Test code with special JavaScript characters."""
    code = "describe('test with special chars: !@#$%^&*()', () => { test('case', () => {}); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 8.59μs -> 7.34μs (16.9% faster)

def test_unicode_characters_in_code():
    """Test code with unicode characters."""
    code = "describe('测试', () => { test('тест', () => {}); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.66μs -> 8.35μs (15.7% faster)

def test_large_file_with_many_test_cases():
    """Test that import is added correctly to a large file with many test cases."""
    # Create a file with many test cases (but keep count reasonable for testing)
    test_cases = [f"test('case {i}', () => {{ expect({i}).toBe({i}); }});" for i in range(50)]
    code = "describe('large suite', () => {\n  " + "\n  ".join(test_cases) + "\n});"
    
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 32.5μs -> 31.0μs (4.78% faster)
    # Verify all original test cases are still present
    for test_case in test_cases:
        pass

def test_large_file_with_many_different_globals():
    """Test handling of code using many different vitest globals."""
    globals_to_test = ["describe", "test", "it", "expect", "vi", "beforeEach", "afterEach", "beforeAll", "afterAll"]
    code_lines = []
    for global_name in globals_to_test:
        code_lines.append(f"{global_name}(() => {{}});")
    
    code = "\n".join(code_lines)
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.54μs -> 8.08μs (18.1% faster)
    for global_name in globals_to_test:
        pass

def test_large_file_with_mixed_content():
    """Test a large file with various JavaScript content mixed with test code."""
    code_parts = []
    code_parts.append("import axios from 'axios';")
    code_parts.append("const API_URL = 'https://api.example.com';")
    
    # Add many describe blocks
    for i in range(30):
        code_parts.append(f"describe('suite {i}', () => {{")
        code_parts.append(f"  beforeEach(() => {{ console.log('setup {i}'); }});")
        code_parts.append(f"  test('case {i}', () => {{ expect(true).toBe(true); }});")
        code_parts.append("});")
    
    code = "\n".join(code_parts)
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 49.5μs -> 48.4μs (2.40% faster)
    
    # Verify import was added after axios import
    lines = result.split("\n")
    axios_line = next((i for i, l in enumerate(lines) if "axios" in l), -1)
    vitest_line = next((i for i, l in enumerate(lines) if "vitest" in l), -1)

def test_multiple_consecutive_test_files():
    """Test that the function handles multiple calls correctly (as if processing multiple files)."""
    test_files = [
        "test('case1', () => {});",
        "describe('suite', () => { it('case2', () => {}); });",
        "beforeEach(() => {}); afterEach(() => {}); expect(1).toBe(1);",
    ]
    
    results = []
    for file_code in test_files:
        codeflash_output = ensure_vitest_imports(file_code, "vitest"); result = codeflash_output # 19.7μs -> 15.9μs (23.8% faster)
        results.append(result)

def test_code_with_many_existing_imports():
    """Test handling of code with many existing imports."""
    import_lines = [f"import module{i} from 'module-{i}';" for i in range(40)]
    code = "\n".join(import_lines) + "\ndescribe('test', () => {});"
    
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 36.6μs -> 35.0μs (4.53% faster)
    
    # Verify all imports are present
    for import_line in import_lines:
        pass

def test_deeply_nested_function_calls():
    """Test detection in deeply nested function calls."""
    code = "describe('outer', () => { describe('middle', () => { describe('inner', () => { test('deep', () => { expect(1).toBe(1); }); }); }); });"
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 9.18μs -> 7.99μs (14.9% faster)

def test_performance_with_large_code_string():
    """Test that function performs reasonably with a large code string."""
    # Create a large code string (reasonable size)
    lines = []
    for i in range(200):
        if i % 3 == 0:
            lines.append(f"describe('suite{i}', () => {{")
        elif i % 3 == 1:
            lines.append(f"  test('case{i}', () => {{ expect({i}).toBe({i}); }});")
        else:
            lines.append("});")
    
    code = "\n".join(lines)
    
    # Function should complete without timeout/performance issues
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 69.1μs -> 67.8μs (1.94% faster)

def test_all_globals_used_in_large_file():
    """Test a file using all test globals multiple times."""
    code_parts = []
    
    for i in range(25):
        code_parts.append(f"describe('suite{i}', () => {{")
        code_parts.append(f"  beforeAll(() => {{ console.log('all setup'); }});")
        code_parts.append(f"  beforeEach(() => {{ console.log('each setup'); }});")
        code_parts.append(f"  afterEach(() => {{ console.log('each cleanup'); }});")
        code_parts.append(f"  afterAll(() => {{ console.log('all cleanup'); }});")
        code_parts.append(f"  test('test case', () => {{ expect(1).toBe(1); }});")
        code_parts.append(f"  it('it case', () => {{ vi.mock('./module'); }});")
        code_parts.append("});")
    
    code = "\n".join(code_parts)
    codeflash_output = ensure_vitest_imports(code, "vitest"); result = codeflash_output # 56.4μs -> 55.1μs (2.42% faster)
    
    # Verify all globals are in import
    all_globals = ["describe", "beforeAll", "beforeEach", "afterEach", "afterAll", "test", "it", "expect", "vi"]
    for global_name in all_globals:
        pass
# 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-pr1289-2026-02-03T11.36.53 and push.