⚡️ Speed up function _apply_indentation by 140% in PR #1199 (omni-java)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1199

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

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

---

📄 140% (1.40x) speedup for _apply_indentation in codeflash/languages/java/replacement.py

⏱️ Runtime : 1.86 milliseconds → 776 microseconds (best of 177 runs)

📝 Explanation and details

The optimized code achieves a 140% speedup (from 1.86ms to 776μs) by eliminating expensive regex operations and reducing redundant function calls.

Key Optimizations

1. Replaced Regex with Direct String Operations
The original _get_indentation() used re.match(r"^(\s*)", line) for every line, which is costly. The optimized version calculates indentation length using len(line) - len(line.lstrip()) and returns line[:indent_len]. This eliminates regex overhead entirely - as shown in the line profiler, the original _get_indentation() consumed 83.5% of its time in regex matching (4.09ms out of 4.89ms).

2. Eliminated Redundant Function Calls
The original code called _get_indentation() for 1,744 lines (61.5% of total time in _apply_indentation()), while the optimized version inlines the calculation. This reduces function call overhead and allows the calculation to reuse stripped_line already computed via line.lstrip().

3. Optimized Indentation Prefix Checking
Instead of calling line_indent.startswith(existing_indent), the optimized code uses length comparison (line_indent_len >= existing_indent_len) followed by direct string slicing (line[:existing_indent_len] == existing_indent). This avoids creating intermediate strings and leverages the fact that we already know the indentation lengths.

4. Cached Indentation Length
The optimized version stores existing_indent_len alongside existing_indent, eliminating repeated length calculations during the prefix check for each line.

Performance Impact

The test results show consistent improvements across all scenarios:

• Small inputs (single/few lines): 100-133% faster
• Large inputs (500 lines): 161-200% faster
• Deep nesting (100 levels): 121% faster
• Long content lines: 84.7% faster

The optimization is particularly effective for:

• Code with many indented lines (typical Java code structure)
• Deeply nested blocks where indentation calculations are repeated frequently
• Large files where the regex overhead compounds

Since this function likely processes Java code formatting in a hot path (based on its location in replacement.py), the 140% speedup significantly reduces latency for code transformation operations.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from __future__ import annotations

import re
import string

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.replacement import _apply_indentation

def test_empty_input_returns_empty_string():
    # If the input list is empty, the function should return an empty string.
    codeflash_output = _apply_indentation([], "    ") # 340ns -> 391ns (13.0% slower)

def test_single_line_no_existing_indent_applies_base_indent():
    # Single non-empty line with no leading whitespace; base_indent should be prepended.
    lines = ["public class A {\n"]
    base = "    "  # four spaces
    # Expect base + original (since no existing indentation to remove)
    expected = base + "public class A {\n"
    codeflash_output = _apply_indentation(lines, base) # 5.73μs -> 2.48μs (131% faster)

def test_preserve_blank_lines_and_apply_relative_indentation():
    # Mixed blank lines and indented lines. First non-empty line determines existing_indent.
    lines = [
        "\n",                 # blank line should be preserved exactly
        "    int x;\n",       # first non-empty line: existing_indent = 4 spaces
        "    // comment\n",  # same indent as existing_indent -> relative_indent empty
        "        int y;\n",   # deeper indent -> relative_indent = 4 spaces
        "\n",                 # trailing blank line preserved
    ]
    base = "\t"  # use a single tab as base indent
    codeflash_output = _apply_indentation(lines, base); result = codeflash_output # 8.86μs -> 4.67μs (89.7% faster)
    # Build expected manually:
    # blank line preserved
    # line 2: base + (relative "") + stripped_line
    # line 3: base + "" + "// comment\n"
    # line 4: base + "    " + "int y;\n"
    expected = (
        "\n"
        + base + "int x;\n"
        + base + "// comment\n"
        + base + "    " + "int y;\n"
        + "\n"
    )

def test_existing_indent_mismatch_with_tabs_and_spaces_removes_indent():
    # When a later line's indentation does not start with existing_indent,
    # its indentation should be discarded (relative_indent = "").
    lines = [
        "    first;\n",  # existing_indent is 4 spaces
        "\tsecond;\n",   # tab does not start with 4 spaces -> indent removed
    ]
    base = "--"
    expected = "--first;\n--second;\n"
    codeflash_output = _apply_indentation(lines, base) # 6.96μs -> 3.18μs (119% faster)

def test_first_non_empty_has_no_indent_but_others_do_preserve_relative_indent():
    # If the first non-empty line has no indent, existing_indent == ""
    # So later lines should keep their original indentation appended after base_indent.
    lines = [
        "\n",               # blank preserved
        "class C {\n",      # first non-empty, existing_indent = ""
        "    int x;\n",     # should keep 4-space indent after base
        "        int y;\n", # should keep 8-space indent after base
    ]
    base = "  "  # two spaces
    codeflash_output = _apply_indentation(lines, base); result = codeflash_output # 8.61μs -> 4.29μs (101% faster)
    expected = (
        "\n"
        + base + "class C {\n"
        + base + "    " + "int x;\n"
        + base + "        " + "int y;\n"
    )

def test_lines_with_only_whitespace_are_preserved_exactly():
    # Lines that contain only whitespace (spaces or tabs) are considered empty by
    # line.strip() and should be preserved without modification.
    lines = [
        "    \n",  # spaces-only line
        "\t\t\n",  # tabs-only line
        "  \t  \n",# mixed whitespace-only line
        "noindent\n",  # first non-empty, existing_indent becomes ""
        "    indented\n"
    ]
    base = ">"
    # The first three lines should be preserved verbatim.
    # After "noindent" (first non-empty), existing_indent is "", so subsequent indented
    # lines should keep their original indentation appended after base.
    expected = (
        "    \n"
        "\t\t\n"
        "  \t  \n"
        + base + "noindent\n"
        + base + "    " + "indented\n"
    )
    codeflash_output = _apply_indentation(lines, base) # 7.59μs -> 4.00μs (90.0% faster)

def test_line_with_shorter_indent_than_existing_gets_indent_removed():
    # existing_indent is larger than a later line's indent -> relative_indent = ""
    lines = [
        "        a;\n",  # existing_indent = 8 spaces
        "    b;\n",      # 4 spaces; does not startwith 8 spaces -> removed
    ]
    base = "."
    expected = "." + "a;\n" + "." + "b;\n"
    # Note: for 'a;' and 'b;' the stripped_line keeps trailing newline.
    codeflash_output = _apply_indentation(lines, base) # 6.99μs -> 3.32μs (111% faster)

def test_mixed_tabs_and_spaces_complex_case():
    # First non-empty uses tabs; a later line uses tabs + spaces starting with the same tabs
    lines = [
        "\t\t/**\n",       # first non-empty -> existing_indent = 2 tabs
        "\t\t * Comment\n",# startswith existing_indent, relative_indent = " "
        "\t    weird;\n",  # line_indent = tab + 4 spaces -> does not startwith 2 tabs -> removed
        "\t\t\tdeep;\n",   # 3 tabs startswith 2 tabs -> relative_indent = 1 tab
    ]
    base = "  "  # two spaces as base
    expected = (
        # first line: base + stripped line (no extra relative because relative is "")
        base + "/**\n"
        # second: base + " " (one space relative) + "* Comment\n"
        + base + " " + "* Comment\n"
        # third: does not startwith existing_indent -> relative empty
        + base + "weird;\n"
        # fourth: startswith existing_indent (2 tabs) -> relative 1 tab
        + base + "\t" + "deep;\n"
    )
    codeflash_output = _apply_indentation(lines, base) # 9.27μs -> 4.38μs (112% faster)

def test_large_scale_many_lines_varied_indentation_performance_and_correctness():
    # Create a large but bounded number of lines (500) with a predictable pattern.
    # - The first non-empty line will determine existing_indent.
    # - Subsequent lines alternate between having more indent, equal indent, less indent,
    #   and a completely different indent character (tab) to exercise the branches.
    n = 500  # well under 1000 as required
    lines = []
    # Start with some blank lines to ensure the search for first non-empty works.
    lines.extend(["\n", "   \n"])
    # First non-empty line: 4-space indent
    lines.append("    root_line_0\n")  # existing_indent = 4 spaces now
    # Now append a pattern
    for i in range(1, n):
        if i % 4 == 0:
            # deeper: 8 spaces
            lines.append("        deeper_line_%d\n" % i)
        elif i % 4 == 1:
            # equal indent: 4 spaces
            lines.append("    same_line_%d\n" % i)
        elif i % 4 == 2:
            # shorter indent: 2 spaces -> will not startwith existing_indent -> removed
            lines.append("  short_line_%d\n" % i)
        else:
            # completely different indent char: a tab -> mismatch and will be removed
            lines.append("\t_tab_line_%d\n" % i)

    base = "--"  # two dashes as base indent

    codeflash_output = _apply_indentation(lines, base); result = codeflash_output # 424μs -> 141μs (200% faster)

    # Build expected output deterministically according to the function's rules.
    expected_parts = []
    # preserve first two blank lines as-is
    expected_parts.append("\n")
    expected_parts.append("   \n")
    # first non-empty gets base + stripped
    expected_parts.append("--" + "root_line_0\n")
    for i in range(1, n):
        if i % 4 == 0:
            # deeper_line has indent starting with existing_indent ("    "), so
            # relative_indent = 4 spaces
            expected_parts.append("--" + "    " + "deeper_line_%d\n" % i)
        elif i % 4 == 1:
            # same indent -> relative empty
            expected_parts.append("--" + "same_line_%d\n" % i)
        elif i % 4 == 2:
            # "  " does not startwith "    " -> relative empty -> indent removed
            expected_parts.append("--" + "short_line_%d\n" % i)
        else:
            # tab does not startwith spaces -> removed
            expected_parts.append("--" + "_tab_line_%d\n" % i)

    expected = "".join(expected_parts)

def test_preserve_newline_characters_and_no_extra_added_or_removed():
    # Ensure that trailing newline characters and exact string contents are preserved,
    # except for the intended indentation transformation.
    lines = [
        "\n",                       # preserved
        "    line_with_nl\n",       # preserved nl after transform
        "    line_without_nl",      # no newline at end
    ]
    base = " "
    codeflash_output = _apply_indentation(lines, base); result = codeflash_output # 7.32μs -> 3.48μs (111% faster)
    # Build expected carefully: last line had no newline and should remain that way.
    expected = (
        "\n"
        + " " + "line_with_nl\n"
        + " " + "line_without_nl"
    )

def test_indentation_not_accidentally_duplicated_or_lost_for_various_combinations():
    # This test combines many small variations to make sure indentation logic is exact.
    lines = [
        "    a\n",     # existing_indent = 4 spaces
        "        b\n", # should preserve 4-space relative indent
        "    c\n",     # no relative indent
        "\td\n",       # tab -> removed
        " \te\n",      # leading space then tab; line_indent is " \t" which does not startwith "    " -> removed
        "    f\n",     # equal indent again
        "\n",          # preserved
        "        g\n", # deeper again
    ]
    base = ">"
    codeflash_output = _apply_indentation(lines, base); result = codeflash_output # 12.5μs -> 5.63μs (122% faster)
    expected = (
        ">a\n"
        + ">" + "    " + "b\n"
        + ">" + "c\n"
        + ">" + "d\n"
        + ">" + "e\n"
        + ">" + "f\n"
        + "\n"
        + ">" + "    " + "g\n"
    )
# 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.java.replacement import _apply_indentation

def test_empty_lines_list():
    """Test with an empty list of lines - should return empty string."""
    codeflash_output = _apply_indentation([], "    "); result = codeflash_output # 380ns -> 381ns (0.262% slower)

def test_single_line_no_indentation():
    """Test with a single line that has no indentation."""
    lines = ["public void method() {"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 5.38μs -> 2.35μs (129% faster)

def test_single_line_with_indentation():
    """Test with a single line that already has indentation."""
    lines = ["    int x = 5;"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 5.53μs -> 2.62μs (112% faster)

def test_multiple_lines_no_indentation():
    """Test multiple lines with no existing indentation."""
    lines = ["public void test() {", "int x = 5;", "}"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.53μs -> 3.39μs (123% faster)

def test_multiple_lines_with_consistent_indentation():
    """Test multiple lines with consistent existing indentation."""
    lines = ["    public void test() {", "        int x = 5;", "    }"]
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 8.49μs -> 4.09μs (108% faster)

def test_base_indent_with_tabs():
    """Test applying tab-based indentation."""
    lines = ["public void test() {", "int x = 5;", "}"]
    codeflash_output = _apply_indentation(lines, "\t"); result = codeflash_output # 7.50μs -> 3.36μs (124% faster)

def test_empty_base_indent():
    """Test with empty base indentation (no indentation to add)."""
    lines = ["    public void test() {", "        int x = 5;", "    }"]
    codeflash_output = _apply_indentation(lines, ""); result = codeflash_output # 8.38μs -> 4.06μs (107% faster)

def test_lines_with_empty_strings():
    """Test with empty string lines in the middle."""
    lines = ["public void test() {", "", "int x = 5;", "}"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.88μs -> 3.57μs (121% faster)

def test_lines_with_only_whitespace():
    """Test with lines that contain only whitespace."""
    lines = ["public void test() {", "    ", "int x = 5;", "}"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.71μs -> 3.45μs (124% faster)

def test_mixed_tabs_and_spaces():
    """Test with mixed tabs and spaces in original indentation."""
    lines = ["\t    public void test() {", "\t        int x = 5;", "\t    }"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 8.56μs -> 4.22μs (103% faster)

def test_deeply_nested_indentation():
    """Test with deeply nested code structure."""
    lines = [
        "    if (true) {",
        "        if (false) {",
        "            System.out.println();",
        "        }",
        "    }",
    ]
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 10.9μs -> 5.28μs (106% faster)

def test_first_line_empty_remaining_indented():
    """Test when first line is empty but subsequent lines are indented."""
    lines = ["", "    int x = 5;", "    int y = 10;"]
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 7.18μs -> 3.59μs (100% faster)

def test_all_lines_empty_or_whitespace():
    """Test when all lines are empty or contain only whitespace."""
    lines = ["", "    ", "\t", "  "]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 1.93μs -> 2.07μs (6.75% slower)

def test_single_character_lines():
    """Test with lines containing single non-whitespace characters."""
    lines = ["a", "b", "c"]
    codeflash_output = _apply_indentation(lines, "  "); result = codeflash_output # 7.75μs -> 3.41μs (127% faster)

def test_very_large_base_indentation():
    """Test with a very large base indentation string."""
    lines = ["int x = 5;"]
    base_indent = "    " * 10  # 40 spaces
    codeflash_output = _apply_indentation(lines, base_indent); result = codeflash_output # 5.32μs -> 2.28μs (133% faster)

def test_newline_preservation():
    """Test that newline characters in lines are preserved."""
    lines = ["public void test() {\n", "int x = 5;\n", "}\n"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.84μs -> 3.62μs (117% faster)

def test_line_with_trailing_spaces():
    """Test lines that have trailing spaces after content."""
    lines = ["int x = 5;  ", "int y = 10;  "]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 6.70μs -> 3.00μs (124% faster)

def test_inconsistent_indentation_levels():
    """Test with inconsistent indentation (not all multiples of first)."""
    lines = ["  public void test() {", "    int x = 5;", "  }"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 8.52μs -> 4.17μs (104% faster)

def test_relative_indentation_calculation():
    """Test correct calculation of relative indentation."""
    lines = ["    int x = 5;", "        int y = 10;", "    int z = 15;"]
    codeflash_output = _apply_indentation(lines, ""); result = codeflash_output # 8.32μs -> 3.94μs (111% faster)

def test_base_indent_longer_than_existing():
    """Test when base indentation is longer than existing indentation."""
    lines = ["int x = 5;", "int y = 10;"]
    codeflash_output = _apply_indentation(lines, "            "); result = codeflash_output # 6.60μs -> 3.01μs (120% faster)

def test_comments_with_indentation():
    """Test Javadoc and comment lines are handled correctly."""
    lines = ["    /**", "     * Documentation", "     */", "    public void test() {}"]
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 9.43μs -> 4.63μs (104% faster)

def test_special_characters_in_content():
    """Test lines with special characters and symbols."""
    lines = ["int[] arr = {1, 2, 3};", "String str = \"hello\";"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 6.55μs -> 2.87μs (129% faster)

def test_unicode_characters_in_content():
    """Test lines with unicode characters."""
    lines = ["// Comment with unicode: \u2665", "String s = \"\u2665\";"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.76μs -> 3.52μs (121% faster)

def test_only_tabs_indentation():
    """Test with only tabs as indentation in original lines."""
    lines = ["\t\tint x = 5;", "\t\t\tint y = 10;"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.22μs -> 3.58μs (102% faster)

def test_mixed_empty_and_content_lines():
    """Test alternating empty and content lines."""
    lines = ["int x = 5;", "", "int y = 10;", "", "int z = 15;"]
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 7.91μs -> 3.63μs (118% faster)

def test_large_number_of_lines():
    """Test performance with a large number of lines (500 lines)."""
    # Create 500 lines with consistent indentation
    lines = ["    int var" + str(i) + " = " + str(i) + ";" for i in range(500)]
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 431μs -> 165μs (161% faster)
    
    # Verify result contains expected number of lines and proper indentation
    result_lines = result.split("\n")

def test_very_deeply_nested_structure():
    """Test with very deeply nested indentation (100 levels deep)."""
    # Create a deeply nested structure
    lines = []
    for i in range(100):
        indent = "    " * i
        lines.append(indent + "level_" + str(i))
    
    codeflash_output = _apply_indentation(lines, "  "); result = codeflash_output # 149μs -> 67.8μs (121% faster)

def test_large_base_indent_string():
    """Test with a very large base indentation string."""
    # Create a base indent of 256 spaces
    large_base = " " * 256
    lines = ["int x = 5;", "int y = 10;"]
    codeflash_output = _apply_indentation(lines, large_base); result = codeflash_output # 6.80μs -> 3.12μs (118% faster)

def test_many_lines_mixed_content():
    """Test with 300 lines of mixed content (some empty, some with varying indentation)."""
    lines = []
    for i in range(300):
        if i % 5 == 0:
            # Empty line
            lines.append("")
        elif i % 7 == 0:
            # Whitespace only
            lines.append("    ")
        else:
            # Content with varying indentation
            indent_level = (i % 10)
            indent = "  " * indent_level
            lines.append(indent + "line_" + str(i))
    
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 203μs -> 82.3μs (147% faster)

def test_performance_large_lines_with_long_content():
    """Test performance with 100 lines of long content."""
    # Create lines with long content
    long_content = "x" * 1000  # 1000 character content
    lines = ["    " + long_content for _ in range(100)]
    
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 118μs -> 64.2μs (84.7% faster)

def test_large_relative_indentation_preservation():
    """Test preservation of relative indentation across many lines."""
    # Create lines with varying relative indentation
    base_lines = []
    for level in range(50):
        indent = "    " * level
        base_lines.append(indent + "code_at_level_" + str(level))
    
    codeflash_output = _apply_indentation(base_lines, "        "); result = codeflash_output # 65.4μs -> 28.2μs (131% faster)

def test_extreme_whitespace_scenario():
    """Test with extreme whitespace scenarios (500 empty lines with various whitespace)."""
    lines = []
    for i in range(500):
        if i % 3 == 0:
            lines.append("")
        elif i % 3 == 1:
            lines.append("    ")
        else:
            lines.append("\t\t")
    
    codeflash_output = _apply_indentation(lines, "    "); result = codeflash_output # 36.3μs -> 37.2μs (2.45% slower)

def test_large_scale_javadoc_block():
    """Test with large Javadoc comment block (200 lines)."""
    lines = []
    lines.append("    /**")
    for i in range(198):
        lines.append("     * Line " + str(i))
    lines.append("     */")
    
    codeflash_output = _apply_indentation(lines, "        "); result = codeflash_output # 176μs -> 66.4μs (166% faster)
# 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-pr1199-2026-02-03T11.26.46 and push.

[KRRT7]

Closing stale bot PR.