⚡️ Speed up method JavaLineProfiler.instrument_function by 26% in PR #1543 (fix/java/line-profiler)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1543

If you approve this dependent PR, these changes will be merged into the original PR branch fix/java/line-profiler.

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

---

📄 26% (0.26x) speedup for JavaLineProfiler.instrument_function in codeflash/languages/java/line_profiler.py

⏱️ Runtime : 2.06 milliseconds → 1.64 milliseconds (best of 193 runs)

📝 Explanation and details

Runtime improvement: the optimized version runs ~25% faster (2.06 ms -> 1.64 ms), with larger wins on functions with many instrumentable lines.

What changed

• Precompute file_path.as_posix() once per function: file_posix = file_path.as_posix() and reuse it for content_key and the profiled f-string instead of calling file_path.as_posix() repeatedly inside the loop.
• Combined multiple startswith checks into a single startswith(("//", "/", "")) call to replace three separate str.startswith() calls.

Why this speeds things up

• Attribute lookups and small method calls are relatively expensive in Python. In the original code file_path.as_posix() was called twice for every instrumented line (once for content_key and once inside the profiled f-string). Moving that result into a local variable removes those repeated method calls and attribute lookups and replaces them with a fast local variable load.
• Multiple str.startswith() calls were replaced by one startswith(tuple) call, cutting the number of Python-level function calls and condition checks for candidate comment lines.
• These savings multiply with the number of lines inside a function. The loop is the hot path: each instrumented statement previously did several extra method calls and string operations; removing them reduces per-line overhead and thus the total runtime.

Observed evidence

• Line-profiling shows heavy time spent on the two expressions that used file_path.as_posix() repeatedly; those costs drop in the optimized profile.
• The annotated tests show the biggest improvements on the large-scale test (many lines), which matches the expectation that per-line micro-optimizations are most beneficial when the loop has many iterations.

Behavioral impact and trade-offs

• No functional change: the instrumented output and semantics are unchanged.
• A tiny upfront cost (computing file_posix once) is paid even if no lines are instrumented, but that's negligible and worth the per-line savings.
• The exception path (logger.warning) shows a larger percent of the shorter total time in the optimized profile — this is not a regression in practice, just a profiling artifact because the overall runtime decreased; exception handling remains unchanged.

When this matters most

• Hot paths that instrument long functions or many functions (the large-scale test) gain the most.
• Small functions still benefit (the overall runtime measured improved), but the relative improvement is smaller because fixed costs (parse, etc.) dominate.

Summary
Precomputing file_posix and reducing redundant startswith/attribute calls cut down repeated Python-level work inside the main loop. That directly lowers per-line overhead and yields the measured ~25% runtime improvement, especially on workloads with many instrumentable lines.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import inspect
from pathlib import Path

import pytest  # used for our unit tests
from codeflash.languages.base import FunctionInfo
from codeflash.languages.java.line_profiler import JavaLineProfiler

# helper to construct a FunctionInfo instance in a robust way by inspecting its signature
def build_function_info(function_name: str, starting_line: int, ending_line: int) -> FunctionInfo:
    """
    Build a real FunctionInfo instance by inspecting its __init__ signature
    and supplying plausible arguments for parameters based on their names.
    This keeps tests resilient to different FunctionInfo constructor shapes.
    """
    sig = inspect.signature(FunctionInfo)
    kwargs = {}
    for name, param in sig.parameters.items():
        if name == "self":
            continue
        lowered = name.lower()
        # Provide Path for any path-like parameter
        if "path" in lowered or "file" in lowered:
            kwargs[name] = Path("Example.java")
        # Provide function name for name-like params
        elif "name" in lowered or "func" in lowered:
            kwargs[name] = function_name
        # Provide starting/ending lines for line-like params
        elif "start" in lowered or "starting" in lowered or ("line" in lowered and "start" in lowered):
            kwargs[name] = starting_line
        elif "end" in lowered or "ending" in lowered or ("line" in lowered and "end" in lowered):
            kwargs[name] = ending_line
        # Provide integers for generic numeric params
        elif param.annotation in (int,):
            kwargs[name] = starting_line
        # If the parameter has a default, let it be omitted to use default
        elif param.default is not inspect._empty:
            # omit to use default
            pass
        else:
            # Fallbacks for unknown parameter names/types
            if "lines" in lowered or "params" in lowered or "args" in lowered:
                kwargs[name] = []
            else:
                kwargs[name] = None
    # Call with keyword args (should be accepted by most real constructors)
    return FunctionInfo(**kwargs)

# Minimal helper analyzer that exposes parse() and returns an object with root_node
class _MinimalParseResult:
    def __init__(self):
        # Root node is not actually used when we monkeypatch find_executable_lines,
        # but we provide the attribute to satisfy callers.
        self.root_node = None

class MinimalAnalyzer:
    def parse(self, data: bytes):
        # The real JavaLineProfiler.instrument_function wraps parse() in try/except,
        # so returning a simple object with a root_node attribute is sufficient.
        return _MinimalParseResult()

def test_enter_function_and_hit_insertion_basic():
    # Basic test: verify enterFunction() is inserted after the opening brace,
    # and a hit() call is inserted before an executable line.
    # Construct a tiny Java method as lines.
    lines = [
        "    public void foo() {\n",  # line 1 of function: contains '{' -> enterFunction() after this
        "        int x = 1;\n",        # line 2 of function: executable
        "    }\n",                    # line 3 of function: closing brace
    ]
    file_path = Path("src/Example.java")

    # Build a real FunctionInfo instance for these lines.
    func = build_function_info("foo", 10, 12)

    profiler = JavaLineProfiler(output_file=Path("out.json"))
    # Prepare the line_contents mapping used by the method
    profiler.line_contents = {}

    # Use a minimal analyzer. We'll monkeypatch find_executable_lines to mark the second line
    # inside the function (local index 1) as executable.
    analyzer = MinimalAnalyzer()
    # Create the set marking the local line 2 as executable (1-indexed within function)
    expected_local_executable = {2}
    # Monkeypatch the instance method so the internal call doesn't need a real tree-sitter node.
    profiler.find_executable_lines = lambda node: expected_local_executable

    # Call the instrument_function under test
    codeflash_output = profiler.instrument_function(func, lines, file_path, analyzer); instrumented = codeflash_output

    # The executable line (original second line) should be preceded by a hit() insertion.
    # Find the index of the original "int x = 1;" line in the output; the previous line should be a hit() call.
    for idx, out_line in enumerate(instrumented):
        if out_line == lines[1]:
            break
    else:
        pytest.fail("Expected original executable line not found in instrumented output")

    # Verify that profiler.line_contents contains the expected mapping for the global line number
    global_line_num = func.starting_line + 1  # starting_line + local_idx (1)
    content_key = f"{file_path.as_posix()}:{global_line_num}"

def test_skips_comments_closing_braces_and_blank_lines_even_if_executable_reported():
    # Verify that comment lines, closing braces, and blank lines are not instrumented even
    # if find_executable_lines includes them.
    lines = [
        "    public void commented() {\n",  # 1: brace -> enterFunction
        "        // this is a comment\n",  # 2: comment -> should not be instrumented
        "        /* block comment start */\n",  # 3: block comment -> should not be instrumented
        "        * continued comment line\n",  # 4: star-prefixed -> should not be instrumented
        "        int real = 2; // end-of-line comment\n",  # 5: executable -> should be instrumented
        "    }\n",  # 6: closing brace -> should not be instrumented
    ]
    file_path = Path("Comments.java")
    func = build_function_info("commented", 30, 35)

    profiler = JavaLineProfiler(output_file=Path("out_comments.json"))
    profiler.line_contents = {}

    analyzer = MinimalAnalyzer()

    # Pretend parser flags many lines as executable (including the comments and closing brace).
    # The instrument_function should still skip instrumentation on the comment and brace lines.
    # We use 1-indexed local function lines.
    claimed_executables = {2, 3, 4, 5, 6}
    profiler.find_executable_lines = lambda node: claimed_executables

    codeflash_output = profiler.instrument_function(func, lines, file_path, analyzer); instrumented = codeflash_output

    # Ensure the comment lines remain uninstrumented (no hit() immediately before those lines)
    for idx, orig in enumerate(lines):
        if orig.strip().startswith("//") or orig.strip().startswith("/*") or orig.strip().startswith("*") or orig.strip() in ("}", "};"):
            pass

    # Ensure the real executable line was instrumented with a hit() before it
    for idx, out_line in enumerate(instrumented):
        if out_line == lines[4]:
            break
    else:
        pytest.fail("Expected real executable line not instrumented")

def test_none_analyzer_is_handled_as_parse_failure():
    # Passing None for analyzer should be handled gracefully (treated like parse failure).
    lines = [
        "    public void noneAnalyzer() {\n",
        "        int a = 5;\n",
        "    }\n",
    ]
    file_path = Path("NoneAnalyzer.java")
    func = build_function_info("noneAnalyzer", 40, 42)

    profiler = JavaLineProfiler(output_file=Path("out_none.json"))
    profiler.line_contents = {}

    # analyzer is None -> calling parse will raise AttributeError inside instrument_function,
    # which should be caught and cause the function to return original lines.
    codeflash_output = profiler.instrument_function(func, lines, file_path, None); result = codeflash_output # 474μs -> 473μs (0.241% faster)

def test_large_scale_instrumentation_many_lines_and_hits():
    # Construct a large function with 1000 lines (including opening and closing braces),
    # and simulate that every non-brace, non-empty line is executable.
    body_count = 1000  # total number of lines in function (including braces)
    # Build lines: first line contains '{' to trigger enterFunction, middle lines are executable,
    # last line is closing brace.
    func_lines = ["    public void big() {\n"]
    # Add many executable-looking lines
    for i in range(1, body_count - 1):
        func_lines.append(f"        int v{i} = {i};\n")
    func_lines.append("    }\n")  # closing brace

    file_path = Path("Big.java")
    func = build_function_info("big", 100, 100 + len(func_lines) - 1)

    profiler = JavaLineProfiler(output_file=Path("big_out.json"))
    profiler.line_contents = {}

    analyzer = MinimalAnalyzer()

    # Mark all interior lines (1-indexed within function) except the first and last as executable.
    # First line is the signature with '{' (we want the enterFunction insertion there),
    # last line is a closing brace (should not be instrumented even if reported).
    interior_executables = set(range(2, len(func_lines)))  # 2 .. n-1 are interior lines
    profiler.find_executable_lines = lambda node: interior_executables

    codeflash_output = profiler.instrument_function(func, func_lines, file_path, analyzer); instrumented = codeflash_output # 1.08ms -> 668μs (62.0% faster)

    # Count how many hit() insertions should have occurred:
    # All interior_executables except those lines that would be skipped (comments/closing braces).
    # In this construction, the last line is a brace and not in interior_executables; so expected hits == len(func_lines) - 2
    expected_hits = len(func_lines) - 2

    # Each hit() insertion adds one extra line before the original line.
    # Additionally, enterFunction() adds exactly one extra line after the opening brace.
    expected_total_lines = len(func_lines) + expected_hits + 1
    # Check for the hit pattern referencing the file and at least one of the expected global line numbers
    some_global_line = func.starting_line + 1  # second line of function
    expected_key = f"{file_path.as_posix()}:{some_global_line}"
# 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-pr1543-2026-02-25T06.07.49 and push.