⚡️ Speed up method TreeSitterAnalyzer.is_function_exported by 140% in PR #1335 (gpu-flag)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1335

If you approve this dependent PR, these changes will be merged into the original PR branch gpu-flag.

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

---

📄 140% (1.40x) speedup for TreeSitterAnalyzer.is_function_exported in codeflash/languages/treesitter_utils.py

⏱️ Runtime : 18.3 milliseconds → 7.64 milliseconds (best of 201 runs)

📝 Explanation and details

The optimized code achieves a 139% speedup (from 18.3ms to 7.64ms) by implementing an LRU-style export cache using OrderedDict. This optimization dramatically reduces redundant parsing operations when the same source code is analyzed multiple times.

Key Optimizations

1. Export Results Caching

• Adds a thread-safe OrderedDict cache that stores parsed export information keyed by source code
• When find_exports() is called with previously seen source code, it returns cached results instantly instead of reparsing
• Cache uses LRU eviction (least recently used) with a 64-entry limit to prevent unbounded memory growth
• Cache hits avoid the expensive self._walk_tree_for_exports() call, which accounts for ~79% of the original runtime

2. Deep Copying for Safety

• The _copy_exports() helper creates independent copies of cached ExportInfo objects
• This prevents external modifications from corrupting the cache while maintaining the performance benefit
• The copy overhead (~5-9% of optimized runtime) is negligible compared to the parsing cost avoided

3. Thread Safety

• Uses threading.Lock to protect cache access in concurrent scenarios
• Ensures the analyzer can be safely used across multiple threads

Performance Characteristics

The optimization is most effective for workloads with:

• Repeated analysis of the same source code: Cache hits show 10-20x speedup (e.g., test_multiple_named_exports shows 889-1012% faster on subsequent calls)
• Large source files: Tests with 100+ exports show 1600-2000% speedup on repeated checks (test_large_number_of_exports, test_deeply_nested_classes_and_methods)
• High-frequency queries: Functions like is_function_exported() that call find_exports() multiple times benefit significantly

For first-time parsing of unique source code, there's a small overhead (5-9% slower) due to cache management and deep copying. This is an acceptable trade-off given the massive gains on cache hits.

Implementation Notes

The optimization preserves the original two-pass structure in is_function_exported() for clarity, focusing the performance improvement where it matters most: avoiding redundant tree-sitter parsing operations. The cache size of 64 entries balances memory usage with hit rate for typical use cases.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 105 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 2 Passed
📊 Tests Coverage	93.3%

🌀 Click to see Generated Regression Tests

from __future__ import annotations

from types import \
    SimpleNamespace  # lightweight container for export info objects

# imports
import pytest  # used for our unit tests
from codeflash.languages.treesitter_utils import TreeSitterAnalyzer
from tree_sitter import Node, Parser, Tree

# -----------------
# Unit tests below
# -----------------

# NOTE:
# - We avoid relying on the real tree-sitter parser or any other external
#   infrastructure by monkeypatching the instance method `find_exports` on the
#   TreeSitterAnalyzer instance to return crafted ExportInfo-like objects.
# - The ExportInfo-like objects are SimpleNamespace instances with the exact
#   attributes accessed by is_function_exported: `default_export` and
#   `exported_names`. This keeps tests focused on the logic of
#   is_function_exported without changing its implementation.
# - We pass a non-string object for `language` when instantiating the analyzer
#   to avoid needing TreeSitterLanguage.

def _make_export(default_export=None, exported_names=None):
    """
    Helper to create an ExportInfo-like object.

    - default_export: string name of default export or None
    - exported_names: list of (name, alias) tuples. alias may be None.
    """
    if exported_names is None:
        exported_names = []
    return SimpleNamespace(default_export=default_export, exported_names=exported_names)

def test_named_export_basic():
    # Basic scenario: function 'foo' is exported as a named export without alias.
    analyzer = TreeSitterAnalyzer(object())  # pass dummy language object to avoid TreeSitterLanguage
    # Simulate an export record: export { foo }
    exports = [_make_export(default_export=None, exported_names=[("foo", None)])]
    # Monkeypatch the instance's find_exports to return our simulated exports.
    analyzer.find_exports = lambda source: exports

    # Call is_function_exported and assert it detects the named export.
    codeflash_output = analyzer.is_function_exported("irrelevant source", "foo"); result = codeflash_output # 1.34μs -> 1.41μs (5.02% slower)

def test_named_export_with_alias():
    # Function exported with an alias: export { foo as bar } -> exported_names = [("foo","bar")]
    analyzer = TreeSitterAnalyzer(object())
    exports = [_make_export(default_export=None, exported_names=[("foo", "bar")])]
    analyzer.find_exports = lambda source: exports

    # Searching for function_name 'foo' should report alias 'bar'
    codeflash_output = analyzer.is_function_exported("", "foo"); result = codeflash_output # 1.23μs -> 1.30μs (5.38% slower)

def test_default_export_function():
    # Default export: export default foo; represented by default_export == 'foo'
    analyzer = TreeSitterAnalyzer(object())
    exports = [_make_export(default_export="myFunc", exported_names=[])]
    analyzer.find_exports = lambda source: exports

    # Searching for 'myFunc' should be detected as default export
    codeflash_output = analyzer.is_function_exported("any", "myFunc"); result = codeflash_output # 931ns -> 971ns (4.12% slower)

def test_function_not_exported_returns_false():
    # No export entries contain the function
    analyzer = TreeSitterAnalyzer(object())
    exports = [
        _make_export(default_export=None, exported_names=[("other", None)]),
    ]
    analyzer.find_exports = lambda source: exports

    # 'missing' is not exported; expect False
    codeflash_output = analyzer.is_function_exported("", "missing"); result = codeflash_output # 1.21μs -> 1.19μs (1.76% faster)

def test_class_method_export_via_class_name():
    # Class 'MyClass' is exported as a named export; method 'doThing' should be considered exported when class_name is provided.
    analyzer = TreeSitterAnalyzer(object())
    exports = [_make_export(default_export=None, exported_names=[("MyClass", None)])]
    analyzer.find_exports = lambda source: exports

    # Check method 'doThing' inside class 'MyClass' -> should be considered exported via class export
    codeflash_output = analyzer.is_function_exported("", "doThing", class_name="MyClass"); result = codeflash_output # 1.76μs -> 1.77μs (0.564% slower)

def test_class_method_export_via_class_alias():
    # Class exported with alias: class C exported as ExportedC
    analyzer = TreeSitterAnalyzer(object())
    exports = [_make_export(default_export=None, exported_names=[("C", "ExportedC")])]
    analyzer.find_exports = lambda source: exports

    # Method in class 'C' should be considered exported and return the alias 'ExportedC'
    codeflash_output = analyzer.is_function_exported("", "someMethod", class_name="C"); result = codeflash_output # 1.67μs -> 1.69μs (1.30% slower)

def test_alias_name_does_not_match_function_name():
    # Ensure that only the original name (left side) is compared to function_name,
    # not the alias. E.g., exported_names = [("orig", "alias")] should match function_name 'orig' but not 'alias'.
    analyzer = TreeSitterAnalyzer(object())
    exports = [_make_export(default_export=None, exported_names=[("orig", "alias")])]
    analyzer.find_exports = lambda source: exports

    # Searching for 'alias' should NOT match, because the code compares the source name, not alias.
    codeflash_output = analyzer.is_function_exported("", "alias"); result_alias_search = codeflash_output # 1.10μs -> 1.14μs (3.50% slower)

    # Searching for the original name 'orig' should match and return alias
    codeflash_output = analyzer.is_function_exported("", "orig"); result_orig_search = codeflash_output # 752ns -> 742ns (1.35% faster)

def test_function_and_class_name_conflict_prefers_function_export():
    # If function_name and class_name are equal and that name is a default export,
    # the function check (earlier in code) should detect it as default for the function itself.
    analyzer = TreeSitterAnalyzer(object())
    # default_export set to 'Thing' should be found in the function check block
    exports = [_make_export(default_export="Thing", exported_names=[])]
    analyzer.find_exports = lambda source: exports

    # Provide both function_name and class_name identical; the function path should return default
    codeflash_output = analyzer.is_function_exported("", "Thing", class_name="Thing"); result = codeflash_output # 1.04μs -> 1.08μs (3.70% slower)

def test_large_scale_exports_scan_efficiency_and_correctness():
    # Large-scale scenario: create many exported entries to ensure the scanning loop behaves correctly.
    # We'll keep the number well under 1000 per instructions, but large enough to test performance logic.
    analyzer = TreeSitterAnalyzer(object())

    num_entries = 500  # less than 1000 as required
    exports = []
    # Create many non-matching export entries
    for i in range(num_entries - 1):
        name = f"func{i}"
        # no alias for these
        exports.append(_make_export(default_export=None, exported_names=[(name, None)]))

    # Put our target as the last entry with an alias, ensuring the loop must scan through many entries
    target_name = "targetFunction"
    target_alias = "targetAlias"
    exports.append(_make_export(default_export=None, exported_names=[(target_name, target_alias)]))

    analyzer.find_exports = lambda source: exports

    # Searching for target_function should succeed and return its alias
    codeflash_output = analyzer.is_function_exported("", target_name); result = codeflash_output # 64.6μs -> 62.0μs (4.17% faster)

    # Also validate that a non-existent function still returns False even after scanning many entries
    codeflash_output = analyzer.is_function_exported("", "not_present"); result_missing = codeflash_output # 61.5μs -> 59.8μs (2.78% faster)

def test_multiple_exports_with_same_name_first_match_wins():
    # If multiple exports mention the same function name, the first match should be returned.
    analyzer = TreeSitterAnalyzer(object())
    exports = [
        _make_export(default_export=None, exported_names=[("dup", "firstAlias")]),
        _make_export(default_export=None, exported_names=[("dup", "secondAlias")]),
    ]
    analyzer.find_exports = lambda source: exports

    codeflash_output = analyzer.is_function_exported("", "dup"); result = codeflash_output # 1.18μs -> 1.23μs (4.14% slower)

def test_empty_exports_list_returns_false():
    # If find_exports returns an empty list, the function should always return (False, None)
    analyzer = TreeSitterAnalyzer(object())
    analyzer.find_exports = lambda source: []

    codeflash_output = analyzer.is_function_exported("", "anything"); result = codeflash_output # 831ns -> 792ns (4.92% 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.treesitter_utils import TreeSitterAnalyzer

def test_function_direct_export():
    """Test detection of directly exported function using named export."""
    source = """
export function greet(name) {
    return `Hello, ${name}!`;
}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "greet") # 49.7μs -> 53.9μs (7.88% slower)

def test_function_default_export():
    """Test detection of function exported as default export."""
    source = """
function calculate(x, y) {
    return x + y;
}

export default calculate;
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "calculate") # 48.5μs -> 52.6μs (7.78% slower)

def test_function_with_alias_export():
    """Test detection of exported function with an alias."""
    source = """
function internalName() {
    return 42;
}

export { internalName as publicName };
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "internalName") # 44.2μs -> 47.5μs (6.84% slower)

def test_function_not_exported():
    """Test that non-exported functions are correctly identified."""
    source = """
function privateFunction() {
    return 'secret';
}

export function publicFunction() {
    return 'public';
}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "privateFunction") # 50.9μs -> 53.9μs (5.58% slower)

def test_class_method_with_exported_class():
    """Test detection of class method when the class itself is exported."""
    source = """
export class Calculator {
    add(a, b) {
        return a + b;
    }
}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(
        source, "add", class_name="Calculator"
    ) # 47.7μs -> 51.2μs (6.90% slower)

def test_class_method_without_exported_class():
    """Test that class methods are not exported if the class is not exported."""
    source = """
class Calculator {
    multiply(a, b) {
        return a * b;
    }
}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(
        source, "multiply", class_name="Calculator"
    ) # 36.5μs -> 39.2μs (6.73% slower)

def test_multiple_named_exports():
    """Test detection among multiple named exports."""
    source = """
export function foo() {}
export function bar() {}
export function baz() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    
    is_exported_foo, export_name_foo = analyzer.is_function_exported(source, "foo") # 53.9μs -> 57.9μs (6.88% slower)
    
    is_exported_bar, export_name_bar = analyzer.is_function_exported(source, "bar") # 37.4μs -> 3.79μs (889% faster)
    
    is_exported_baz, export_name_baz = analyzer.is_function_exported(source, "baz") # 33.3μs -> 3.00μs (1012% faster)

def test_empty_source_code():
    """Test behavior with empty source code."""
    source = ""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "anyFunction") # 8.93μs -> 10.8μs (17.2% slower)

def test_function_name_in_comment_not_detected():
    """Test that function names in comments are not treated as exports."""
    source = """
// export function greet() {}
function greet() {
    return 'hello';
}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "greet") # 29.3μs -> 31.4μs (6.54% slower)

def test_function_name_partial_match():
    """Test that partial function name matches are not incorrectly detected."""
    source = """
export function greeting() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "greet") # 29.6μs -> 32.6μs (9.20% slower)

def test_function_name_case_sensitive():
    """Test that function name matching is case-sensitive."""
    source = """
export function MyFunction() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported_lower, export_name_lower = analyzer.is_function_exported(
        source, "myfunction"
    ) # 29.1μs -> 31.7μs (8.37% slower)
    
    is_exported_correct, export_name_correct = analyzer.is_function_exported(
        source, "MyFunction"
    ) # 17.5μs -> 2.65μs (561% faster)

def test_multiple_export_statements_same_function():
    """Test behavior when function appears in multiple export contexts."""
    source = """
export function helper() {}
export { helper };
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "helper") # 40.9μs -> 44.7μs (8.49% slower)

def test_export_with_multiple_aliases():
    """Test export with the same function under different names."""
    source = """
function process() {}
export { process as transform, process as convert };
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "process") # 43.5μs -> 46.2μs (5.94% slower)

def test_class_with_exported_class_method():
    """Test class method detection when class is exported with alias."""
    source = """
class MyClass {
    method() {}
}
export { MyClass as ExportedClass };
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(
        source, "method", class_name="MyClass"
    ) # 44.6μs -> 47.3μs (5.66% slower)

def test_function_with_empty_name():
    """Test behavior when searching for function with empty name."""
    source = """
export function myFunc() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "") # 28.9μs -> 31.7μs (8.77% slower)

def test_special_characters_in_function_name():
    """Test handling of special characters in function names (valid identifiers)."""
    source = """
export function _privateHelper() {}
export function $utilityFunc() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    
    is_exported_underscore, export_name_underscore = analyzer.is_function_exported(
        source, "_privateHelper"
    ) # 42.0μs -> 45.4μs (7.53% slower)
    
    is_exported_dollar, export_name_dollar = analyzer.is_function_exported(
        source, "$utilityFunc"
    ) # 28.2μs -> 3.32μs (749% faster)

def test_unicode_in_function_name():
    """Test handling of unicode characters in identifiers (if supported)."""
    source = """
export function myFunc() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    # Test with unicode function name that doesn't exist
    is_exported, export_name = analyzer.is_function_exported(source, "função") # 28.5μs -> 31.2μs (8.68% slower)

def test_nested_function_not_exported():
    """Test that nested functions are handled correctly."""
    source = """
export function outer() {
    function inner() {
        return 42;
    }
    return inner();
}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "inner") # 50.6μs -> 53.8μs (5.87% slower)

def test_function_and_class_same_name():
    """Test when both function and class names are queried."""
    source = """
export function MyName() {}
export class MyClass {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Query function
    is_exported_func, export_name_func = analyzer.is_function_exported(
        source, "MyName"
    ) # 40.3μs -> 44.4μs (9.27% slower)
    
    # Query non-existent class
    is_exported_class, export_name_class = analyzer.is_function_exported(
        source, "MyName", class_name="MyName"
    ) # 26.5μs -> 3.32μs (699% faster)

def test_export_statement_with_whitespace():
    """Test export statements with various whitespace patterns."""
    source = """
export   function   spacedFunction  (  )  {  }
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "spacedFunction") # 29.3μs -> 31.9μs (8.20% slower)

def test_multiline_export_statement():
    """Test export statements spanning multiple lines."""
    source = """
export {
    functionOne,
    functionTwo,
    functionThree
};
"""
    analyzer = TreeSitterAnalyzer("javascript")
    
    is_exported_one, export_name_one = analyzer.is_function_exported(
        source, "functionOne"
    ) # 34.7μs -> 38.2μs (9.14% slower)
    
    is_exported_three, export_name_three = analyzer.is_function_exported(
        source, "functionThree"
    ) # 21.9μs -> 2.58μs (749% faster)

def test_class_name_none_with_regular_function():
    """Test that class_name=None works correctly for regular functions."""
    source = """
export function regularFunc() {}
"""
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(
        source, "regularFunc", class_name=None
    ) # 29.6μs -> 32.2μs (8.21% slower)

def test_source_with_syntax_errors():
    """Test handling of source code with syntax errors."""
    source = """
export function validFunc() {}
function invalidFunc( { // syntax error
"""
    analyzer = TreeSitterAnalyzer("javascript")
    # Should still find valid exports
    is_exported, export_name = analyzer.is_function_exported(source, "validFunc") # 56.1μs -> 59.4μs (5.47% slower)

def test_large_number_of_exports():
    """Test detection in source with many export statements."""
    # Build source with 100 named exports
    functions = [f"func{i}" for i in range(100)]
    export_lines = "\n".join([f"export function {func}() {{}}" for func in functions])
    source = export_lines
    
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Test first, middle, and last functions
    is_exported_first, export_name_first = analyzer.is_function_exported(
        source, "func0"
    ) # 978μs -> 1.03ms (5.03% slower)
    
    is_exported_middle, export_name_middle = analyzer.is_function_exported(
        source, "func50"
    ) # 953μs -> 54.1μs (1663% faster)
    
    is_exported_last, export_name_last = analyzer.is_function_exported(
        source, "func99"
    ) # 951μs -> 55.9μs (1604% faster)

def test_large_source_file():
    """Test analysis of large source code file."""
    # Create a large source file with many functions and exports
    functions_code = ""
    for i in range(50):
        functions_code += f"""
function internalFunc{i}() {{
    // Some implementation
    return {i} * 2;
}}

export function publicFunc{i}() {{
    return internalFunc{i}();
}}
"""
    source = functions_code
    
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Test several functions across the file
    for i in [0, 25, 49]:
        is_exported, export_name = analyzer.is_function_exported(
            source, f"publicFunc{i}"
        ) # 4.10ms -> 1.53ms (169% faster)
        
        is_exported_internal, export_name_internal = analyzer.is_function_exported(
            source, f"internalFunc{i}"
        )

def test_many_aliases_for_same_function():
    """Test detection when function has many export aliases."""
    # Create source with single function exported under many names
    base = "export { myFunc"
    for i in range(50):
        base += f" as alias{i}"
        if i < 49:
            base += ","
    base += " };"
    
    source = f"""
function myFunc() {{
    return 'result';
}}
{base}
"""
    
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "myFunc") # 743μs -> 746μs (0.371% slower)

def test_deeply_nested_classes_and_methods():
    """Test class method detection in complex structure."""
    source = """
export class OuterClass {
    constructor() {}
    
    method1() {}
    method2() {}
    method3() {}
    method4() {}
    method5() {}
}

export class AnotherClass {
    anotherMethod() {}
}
"""
    
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Test multiple methods in exported class
    is_exported_1, export_name_1 = analyzer.is_function_exported(
        source, "method1", class_name="OuterClass"
    ) # 83.9μs -> 87.8μs (4.38% slower)
    
    is_exported_5, export_name_5 = analyzer.is_function_exported(
        source, "method5", class_name="OuterClass"
    ) # 62.7μs -> 3.55μs (1668% faster)
    
    is_exported_another, export_name_another = analyzer.is_function_exported(
        source, "anotherMethod", class_name="AnotherClass"
    ) # 56.0μs -> 2.67μs (1994% faster)

def test_mixed_export_styles():
    """Test source with both ES6 named exports and object destructuring exports."""
    source = """
export function directExport1() {}
export function directExport2() {}

function indirectExport1() {}
function indirectExport2() {}
function indirectExport3() {}

export {
    indirectExport1,
    indirectExport2 as renamed,
    indirectExport3
};

export default directExport1;
"""
    
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Test direct exports
    is_exported_direct1, _ = analyzer.is_function_exported(source, "directExport1") # 94.6μs -> 98.6μs (4.00% slower)
    
    # Test indirect exports
    is_exported_indirect1, _ = analyzer.is_function_exported(
        source, "indirectExport1"
    ) # 77.1μs -> 4.35μs (1672% faster)
    
    # Test aliased export
    is_exported_indirect2, export_name_indirect2 = analyzer.is_function_exported(
        source, "indirectExport2"
    ) # 67.9μs -> 3.50μs (1841% faster)

def test_large_export_barrel_file():
    """Test analysis of barrel/index file with many re-exports."""
    # Simulate a typical barrel file pattern
    imports_and_exports = ""
    for i in range(100):
        imports_and_exports += f"export {{ func{i} }} from './module{i}';\n"
    
    source = imports_and_exports
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Test a few exports from the barrel
    is_exported_0, _ = analyzer.is_function_exported(source, "func0") # 1.16ms -> 1.22ms (4.17% slower)
    
    is_exported_50, _ = analyzer.is_function_exported(source, "func50") # 1.15ms -> 53.3μs (2058% faster)
    
    is_exported_99, _ = analyzer.is_function_exported(source, "func99") # 1.15ms -> 56.2μs (1944% faster)

def test_performance_with_large_function_body():
    """Test analysis of function with large implementation."""
    # Create a function with large body
    large_body = "let x = 0;\n"
    for i in range(100):
        large_body += f"x += {i};\n"
    
    source = f"""
export function largeFunc() {{
{large_body}
    return x;
}}
"""
    
    analyzer = TreeSitterAnalyzer("javascript")
    is_exported, export_name = analyzer.is_function_exported(source, "largeFunc") # 450μs -> 451μs (0.111% slower)

def test_non_existent_in_large_file():
    """Test that non-existent functions are correctly identified in large files."""
    # Build source with 100 functions
    functions = ""
    for i in range(100):
        functions += f"export function func{i}() {{}}\n"
    
    source = functions
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Search for non-existent function
    is_exported, export_name = analyzer.is_function_exported(source, "nonExistentFunc") # 982μs -> 1.03ms (4.22% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from codeflash.languages.treesitter_utils import TreeSitterAnalyzer

def test_TreeSitterAnalyzer_is_function_exported():
    TreeSitterAnalyzer.is_function_exported(TreeSitterAnalyzer('tsx'), '', '\x00', class_name='\x00')

🔎 Click to see Concolic Coverage Tests

To edit these changes git checkout codeflash/optimize-pr1335-2026-02-04T02.01.24 and push.