⚡️ Speed up function check_formatter_installed by 29% in PR #1550 (omni-java-refactor-java-support)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1550

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

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

---

📄 29% (0.29x) speedup for check_formatter_installed in codeflash/code_utils/env_utils.py

⏱️ Runtime : 105 milliseconds → 81.9 milliseconds (best of 25 runs)

📝 Explanation and details

The optimized code achieves a 28% runtime improvement (105ms → 81.9ms) by targeting the hot paths in check_formatter_installed and get_language_support_by_common_formatters, which are called frequently during formatter validation workflows.

Key Optimizations

1. Eliminated Repeated Import Overhead (64% → 72.6% of time in one hot path)

The original code imported get_language_support_by_common_formatters on every call to check_formatter_installed. The optimization caches this import in a module-level variable _get_language_support_by_common_formatters, performing the import only once. This transforms a ~596ms import cost spread across 1005 calls into a single ~615ms import, saving significant time in repeated invocations.

2. Fast-Path String Splitting (11.3% → ~0% of total time)

Replaced expensive shlex.split() with a simple .split() for commands without quotes or backslashes. Line profiler shows the original shlex.split(first_cmd) took 105ms (11.3% of total time). The optimized version checks for special characters first and only falls back to shlex.split() when necessary, dramatically reducing parsing overhead for common simple commands.

3. Set-Based Language Detection (30.1% + 22.8% → 12.5% + 8.5% of function time)

Converted formatter lists to module-level frozenset constants (_PY_FORMATTERS, _JS_TS_FORMATTERS) and used set intersection (tokens_set & _PY_FORMATTERS) instead of nested generator expressions with any(). This reduces the original 1.84ms + 1.39ms of any() overhead (52.9% of get_language_support_by_common_formatters time) to just 332μs + 226μs (21% of time).

4. Lazy Registry Initialization

Deferred _ensure_languages_registered() call until after determining if language detection is possible. When .js or .py is already in _EXTENSION_REGISTRY (common case), the expensive registration is skipped entirely. This prevents the ~694μs registration overhead on every call.

5. Reduced Temporary String Allocations

Moved command_str = " ".join(formatter_cmds).replace(" $file", "") computation from always executing (856μs) to only executing in error paths, eliminating this cost for the success path (~99% of calls).

Test Case Performance

The optimizations excel across diverse scenarios:

• Simple commands: Empty/disabled formatters see 5-13% improvements
• Complex parsing: Commands with 100+ arguments show 69.6-491% speedups (e.g., test_formatter_with_many_arguments: 1.65ms → 974μs)
• Repeated calls: Stress test with 1000 calls benefits from cached import and faster parsing
• Mixed workloads: Real-world sequences of formatter checks (50 different formatters) improved 2.85-4.58%

These optimizations are particularly valuable when check_formatter_installed is called in CI/CD pipelines, IDE integrations, or batch processing scenarios where formatter validation happens repeatedly across many files.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import os
import shutil
import stat
import tempfile
from pathlib import Path

import pytest  # used for our unit tests
from codeflash.code_utils.env_utils import check_formatter_installed

# Helper to create a minimal dummy executable file on disk and add its directory to PATH.
def _make_executable_in_path(tmpdir: str, name: str) -> str:
    """
    Create an executable file with the given base name inside tmpdir and ensure
    the tmpdir is at the front of PATH so shutil.which can find it.

    Returns the final filename (without directory), which is the token to pass
    to check_formatter_installed.
    """
    # On Windows shutil.which relies on PATHEXT; create an .exe file on Windows.
    ext = ".exe" if os.name == "nt" else ""
    filename = name + ext
    file_path = Path(tmpdir) / filename

    # Write a trivial file and make it executable.
    file_path.write_text("#!/usr/bin/env sh\nexit 0\n", encoding="utf-8")
    current_mode = file_path.stat().st_mode
    file_path.chmod(current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)

    # Prepend tmpdir to PATH for the current process so shutil.which will find it.
    old_path = os.environ.get("PATH", "")
    os.environ["PATH"] = str(tmpdir) + os.pathsep + old_path

    # Return the base token (without path); shutil.which accepts the base name.
    return name

def test_returns_true_for_empty_and_disabled_list():
    # If no formatters are configured, the function should quickly return True.
    codeflash_output = check_formatter_installed([], exit_on_failure=True) # 781ns -> 732ns (6.69% faster)

    # The literal "disabled" first token is a sentinel that also returns True.
    codeflash_output = check_formatter_installed(["disabled"], exit_on_failure=True) # 411ns -> 391ns (5.12% faster)

def test_returns_true_for_empty_first_command_string():
    # An empty string becomes no tokens after shlex.split -> treated as no command -> True.
    codeflash_output = check_formatter_installed([""], exit_on_failure=True) # 7.82μs -> 1.32μs (491% faster)

    # Whitespace-only first command likewise has no tokens -> True.
    codeflash_output = check_formatter_installed(["   "], exit_on_failure=True) # 5.47μs -> 761ns (619% faster)

def test_none_formatter_cmds_is_treated_as_no_formatters_and_returns_true():
    # Although the signature expects a list, passing None is tolerated by the function
    # because the first check is `if not formatter_cmds:`; this should return True.
    codeflash_output = check_formatter_installed(None, exit_on_failure=True) # 612ns -> 561ns (9.09% faster)

def test_missing_executable_returns_false_for_unlikely_name():
    # Use an extremely unlikely executable name to make this deterministic.
    unlikely_name = "definitely_not_installed_formatter_1234567890"

    # Because the executable cannot be found, the function should return False.
    codeflash_output = check_formatter_installed([f"{unlikely_name} $file"], exit_on_failure=True) # 614μs -> 588μs (4.38% faster)

def test_executable_present_but_language_cannot_be_determined_returns_true(tmp_path):
    # Create a dummy executable and ensure it's discoverable on PATH.
    tmpdir = tempfile.TemporaryDirectory()
    try:
        # Use a non-standard formatter name so language detection (py/js) does not trigger.
        token = _make_executable_in_path(tmpdir.name, "my_custom_formatter")

        # Because the formatter name is not one of the known common formatters,
        # get_language_support_by_common_formatters will return None and the
        # function should simply return True.
        codeflash_output = check_formatter_installed([f"{token} $file"], exit_on_failure=True)
    finally:
        # Restore PATH by removing the temporary directory from the front.
        # This keeps the environment clean for other tests.
        orig_path = os.environ.get("PATH", "")
        parts = orig_path.split(os.pathsep)
        # remove the tmpdir entry if present
        if parts and parts[0] == tmpdir.name:
            parts = parts[1:]
        os.environ["PATH"] = os.pathsep.join(parts)
        tmpdir.cleanup()

def test_non_string_first_command_raises_type_error():
    # If the first element is not a string (for example, a list), shutils.which will
    # be invoked with a non-string argument and should raise a TypeError.
    with pytest.raises(TypeError):
        check_formatter_installed([[1, 2, 3]], exit_on_failure=True) # 5.53μs -> 5.44μs (1.65% faster)

def test_many_repeated_checks_with_valid_executable_are_fast_and_consistent(tmp_path):
    """
    Create a small dummy executable and call check_formatter_installed 1000 times
    to ensure the function performs consistently under repeated invocation.
    We use a non-recognized formatter name so the language-detection path
    short-circuits to returning True rather than attempting registry access.
    """
    tmpdir = tempfile.TemporaryDirectory()
    try:
        token = _make_executable_in_path(tmpdir.name, "fmt_dummy_for_stress")

        # Run the call many times to exercise repeated-path performance.
        for _ in range(1000):
            codeflash_output = check_formatter_installed([f"{token} $file"], exit_on_failure=False)
    finally:
        # Restore PATH and cleanup
        orig_path = os.environ.get("PATH", "")
        parts = orig_path.split(os.pathsep)
        if parts and parts[0] == tmpdir.name:
            parts = parts[1:]
        os.environ["PATH"] = os.pathsep.join(parts)
        tmpdir.cleanup()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import os
import shutil
import tempfile
from pathlib import Path
from unittest.mock import MagicMock, patch

# imports
import pytest
from codeflash.code_utils.env_utils import check_formatter_installed

def test_disabled_formatter_returns_true():
    """Test that 'disabled' formatter always returns True."""
    codeflash_output = check_formatter_installed(["disabled"]); result = codeflash_output # 641ns -> 621ns (3.22% faster)

def test_empty_formatter_list_returns_true():
    """Test that empty formatter list returns True."""
    codeflash_output = check_formatter_installed([]); result = codeflash_output # 562ns -> 561ns (0.178% faster)

def test_formatter_not_found_returns_false():
    """Test that non-existent formatter returns False."""
    # Use a formatter command that definitely doesn't exist
    codeflash_output = check_formatter_installed(["nonexistent_formatter_xyz_123"]); result = codeflash_output # 676μs -> 670μs (0.805% faster)

def test_formatter_not_found_exit_on_failure_false():
    """Test that formatter check with exit_on_failure=False doesn't raise."""
    # Should return False without raising an exception
    codeflash_output = check_formatter_installed(
        ["nonexistent_formatter_xyz_123"], exit_on_failure=False
    ); result = codeflash_output # 603μs -> 588μs (2.50% faster)

def test_multiple_formatters_first_not_found():
    """Test with multiple formatters where first one doesn't exist."""
    codeflash_output = check_formatter_installed(
        ["nonexistent_formatter_xyz", "another_formatter"]
    ); result = codeflash_output # 603μs -> 576μs (4.66% faster)

def test_formatter_with_file_token():
    """Test formatter command containing $file token."""
    codeflash_output = check_formatter_installed(
        ["nonexistent_formatter $file"], exit_on_failure=False
    ); result = codeflash_output # 604μs -> 578μs (4.51% faster)

def test_formatter_cmd_with_complex_path():
    """Test formatter with complex path containing spaces."""
    codeflash_output = check_formatter_installed(
        ["nonexistent/path/with spaces/formatter"], exit_on_failure=False
    ); result = codeflash_output # 541μs -> 513μs (5.53% faster)

def test_formatter_with_arguments():
    """Test formatter command with multiple arguments."""
    codeflash_output = check_formatter_installed(
        ["nonexistent_formatter --config test.json --check"], exit_on_failure=False
    ); result = codeflash_output # 609μs -> 572μs (6.46% faster)

def test_python_language_parameter():
    """Test with explicit python language parameter."""
    codeflash_output = check_formatter_installed(
        ["disabled"], language="python"
    ); result = codeflash_output # 822ns -> 831ns (1.08% slower)

def test_javascript_language_parameter():
    """Test with javascript language parameter."""
    codeflash_output = check_formatter_installed(
        ["disabled"], language="javascript"
    ); result = codeflash_output # 751ns -> 761ns (1.31% slower)

def test_unknown_language_parameter():
    """Test with unknown language parameter."""
    codeflash_output = check_formatter_installed(
        ["disabled"], language="unknown_lang"
    ); result = codeflash_output # 752ns -> 661ns (13.8% faster)

def test_single_formatter_in_list():
    """Test with single formatter in list."""
    codeflash_output = check_formatter_installed(["disabled"]); result = codeflash_output # 531ns -> 541ns (1.85% slower)

def test_formatter_cmd_as_string_with_spaces():
    """Test formatter command that needs parsing."""
    codeflash_output = check_formatter_installed(
        ["nonexistent_formatter arg1 arg2"], exit_on_failure=False
    ); result = codeflash_output # 614μs -> 586μs (4.82% faster)

def test_check_formatter_with_mock_shutil_which():
    """Test formatter check with mocked shutil.which to simulate formatter found."""
    with patch('shutil.which') as mock_which:
        # Mock that the formatter is found
        mock_which.return_value = "/usr/bin/black"
        
        with patch('codeflash.code_utils.env_utils.format_code') as mock_format:
            # Mock successful formatting
            mock_format.return_value = 'print("hello world")'
            
            codeflash_output = check_formatter_installed(
                ["black"], exit_on_failure=False
            ); result = codeflash_output

def test_check_formatter_format_code_raises_exception():
    """Test when format_code raises an exception."""
    with patch('shutil.which') as mock_which:
        # Mock that the formatter is found
        mock_which.return_value = "/usr/bin/black"
        
        with patch('codeflash.code_utils.env_utils.format_code') as mock_format:
            # Mock format_code raising an exception
            mock_format.side_effect = Exception("Formatter error")
            
            codeflash_output = check_formatter_installed(
                ["black"], exit_on_failure=False
            ); result = codeflash_output

def test_check_formatter_file_not_found_exception():
    """Test when format_code raises FileNotFoundError."""
    with patch('shutil.which') as mock_which:
        # Mock that the formatter is found initially
        mock_which.return_value = "/usr/bin/black"
        
        with patch('codeflash.code_utils.env_utils.format_code') as mock_format:
            # Mock format_code raising FileNotFoundError
            mock_format.side_effect = FileNotFoundError("Formatter not found")
            
            codeflash_output = check_formatter_installed(
                ["black"], exit_on_failure=False
            ); result = codeflash_output

def test_returns_boolean():
    """Test that function always returns a boolean."""
    codeflash_output = check_formatter_installed(["disabled"]); result = codeflash_output # 631ns -> 621ns (1.61% faster)
    
    codeflash_output = check_formatter_installed(["nonexistent"], exit_on_failure=False); result = codeflash_output # 599μs -> 586μs (2.33% faster)

def test_exit_on_failure_parameter_true():
    """Test exit_on_failure=True parameter (default)."""
    # With exit_on_failure=True, the function should handle errors gracefully
    # rather than raising (based on the code implementation)
    codeflash_output = check_formatter_installed(
        ["disabled"], exit_on_failure=True
    ); result = codeflash_output # 871ns -> 841ns (3.57% faster)

def test_multiple_formatter_cmds():
    """Test multiple formatter commands in list."""
    codeflash_output = check_formatter_installed(
        ["nonexistent1", "nonexistent2"], exit_on_failure=False
    ); result = codeflash_output # 596μs -> 584μs (2.08% faster)

def test_formatter_cmd_with_quotes():
    """Test formatter command with quoted arguments."""
    codeflash_output = check_formatter_installed(
        ['nonexistent_formatter "quoted arg"'], exit_on_failure=False
    ); result = codeflash_output # 602μs -> 601μs (0.130% faster)

def test_formatter_with_empty_string():
    """Test formatter list containing empty string."""
    codeflash_output = check_formatter_installed([""]); result = codeflash_output # 12.4μs -> 1.65μs (650% faster)

def test_very_long_formatter_command():
    """Test with very long formatter command."""
    long_cmd = "nonexistent_formatter " + " ".join([f"arg{i}" for i in range(100)])
    codeflash_output = check_formatter_installed([long_cmd], exit_on_failure=False); result = codeflash_output # 1.28ms -> 1.04ms (23.1% faster)

def test_formatter_with_special_characters():
    """Test formatter name with special characters."""
    codeflash_output = check_formatter_installed(
        ["nonexistent-formatter@1.0.0"], exit_on_failure=False
    ); result = codeflash_output # 610μs -> 584μs (4.55% faster)

def test_formatter_with_path_separators():
    """Test formatter with path separators."""
    codeflash_output = check_formatter_installed(
        ["/usr/local/bin/nonexistent_formatter"], exit_on_failure=False
    ); result = codeflash_output # 568μs -> 539μs (5.36% faster)

def test_formatter_check_idempotent():
    """Test that calling formatter check multiple times gives same result."""
    codeflash_output = check_formatter_installed(["disabled"]); result1 = codeflash_output # 612ns -> 611ns (0.164% faster)
    codeflash_output = check_formatter_installed(["disabled"]); result2 = codeflash_output # 220ns -> 251ns (12.4% slower)

def test_formatter_check_does_not_modify_input():
    """Test that formatter check doesn't modify input list."""
    formatter_list = ["disabled"]
    original_list = formatter_list.copy()
    check_formatter_installed(formatter_list) # 551ns -> 491ns (12.2% faster)

def test_exit_on_failure_true_no_exception():
    """Test that exit_on_failure=True doesn't cause unexpected exceptions."""
    # Should complete without raising
    codeflash_output = check_formatter_installed(
        ["disabled"], exit_on_failure=True
    ); result = codeflash_output # 792ns -> 801ns (1.12% slower)

def test_exit_on_failure_false_no_exception():
    """Test that exit_on_failure=False completes without exception."""
    codeflash_output = check_formatter_installed(
        ["nonexistent"], exit_on_failure=False
    ); result = codeflash_output # 607μs -> 583μs (4.23% faster)

def test_disabled_with_exit_on_failure_true():
    """Test disabled formatter with exit_on_failure=True."""
    codeflash_output = check_formatter_installed(
        ["disabled"], exit_on_failure=True
    ); result = codeflash_output # 792ns -> 872ns (9.17% slower)

def test_disabled_with_exit_on_failure_false():
    """Test disabled formatter with exit_on_failure=False."""
    codeflash_output = check_formatter_installed(
        ["disabled"], exit_on_failure=False
    ); result = codeflash_output # 772ns -> 771ns (0.130% faster)

def test_nonexistent_with_exit_on_failure_true():
    """Test nonexistent formatter with exit_on_failure=True."""
    codeflash_output = check_formatter_installed(
        ["nonexistent"], exit_on_failure=True
    ); result = codeflash_output # 596μs -> 578μs (3.17% faster)

def test_nonexistent_with_exit_on_failure_false():
    """Test nonexistent formatter with exit_on_failure=False."""
    codeflash_output = check_formatter_installed(
        ["nonexistent"], exit_on_failure=False
    ); result = codeflash_output # 578μs -> 566μs (2.19% faster)

def test_many_formatter_commands_in_sequence():
    """Test checking many different formatter commands sequentially."""
    # Test with many nonexistent formatters
    for i in range(50):
        codeflash_output = check_formatter_installed(
            [f"nonexistent_formatter_{i}"], exit_on_failure=False
        ); result = codeflash_output # 26.6ms -> 25.5ms (4.07% faster)

def test_formatter_with_many_arguments():
    """Test formatter command with many arguments."""
    args = " ".join([f"--arg{i}=value{i}" for i in range(100)])
    codeflash_output = check_formatter_installed(
        [f"nonexistent_formatter {args}"], exit_on_failure=False
    ); result = codeflash_output # 1.65ms -> 974μs (69.6% faster)

def test_repeated_calls_with_same_formatter():
    """Test repeated calls with same formatter command."""
    for _ in range(100):
        codeflash_output = check_formatter_installed(["disabled"]); result = codeflash_output # 17.6μs -> 17.7μs (0.790% slower)

def test_repeated_calls_with_different_formatters():
    """Test repeated calls with different nonexistent formatters."""
    results = []
    for i in range(50):
        codeflash_output = check_formatter_installed(
            [f"nonexistent_{i}"], exit_on_failure=False
        ); result = codeflash_output # 26.4ms -> 25.6ms (2.85% faster)
        results.append(result)

def test_multiple_language_parameters_in_sequence():
    """Test with different language parameters in sequence."""
    languages = ["python", "javascript", "typescript", "java", "unknown"]
    for lang in languages:
        codeflash_output = check_formatter_installed(["disabled"], language=lang); result = codeflash_output # 2.02μs -> 2.03μs (0.492% slower)

def test_consistent_return_type_disabled():
    """Verify disabled formatter always returns True."""
    for _ in range(10):
        codeflash_output = check_formatter_installed(["disabled"]); result = codeflash_output # 2.18μs -> 2.18μs (0.092% faster)

def test_consistent_return_type_nonexistent():
    """Verify nonexistent formatter always returns False."""
    for _ in range(10):
        codeflash_output = check_formatter_installed(
            ["definitely_nonexistent_formatter_xyz"], exit_on_failure=False
        ); result = codeflash_output # 5.47ms -> 5.23ms (4.58% faster)

def test_empty_list_vs_disabled():
    """Test that empty list behaves like disabled."""
    codeflash_output = check_formatter_installed([]); result_empty = codeflash_output # 521ns -> 510ns (2.16% faster)
    codeflash_output = check_formatter_installed(["disabled"]); result_disabled = codeflash_output # 311ns -> 321ns (3.12% 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-pr1550-2026-02-19T23.45.37 and push.

[claude]

Dead variable — _ensure_called is assigned but never read. Remove it.

Suggested change

_ensure_called = False

[claude]

This catches Exception for what should be an ImportError. If the import succeeds but the module has a runtime bug, this silently swallows the error and causes the function to return True (claiming the formatter is installed). Consider narrowing to except ImportError:.

Suggested change

	except ImportError:

[claude]

Since formatter_cmds: list[str], first_cmd is always a str, making the isinstance check always true and the else branch unreachable (mypy flags this as [unreachable]). The original code had the same dead branch in ternary form — consider removing it for clarity:

Suggested change

	if isinstance(first_cmd, str):
	if ('"' not in first_cmd) and ("'" not in first_cmd) and ("\\" not in first_cmd):
	cmd_tokens = first_cmd.split()
	else:
	cmd_tokens = shlex.split(first_cmd)
	else:
	cmd_tokens = [first_cmd]
	if ('"' not in first_cmd) and ("'" not in first_cmd) and ("\\" not in first_cmd):
	cmd_tokens = first_cmd.split()
	else:
	cmd_tokens = shlex.split(first_cmd)

[claude]

PR Review Summary

Prek Checks

✅ Passed — Auto-fixed 3 issues (1 unsorted import, 2 formatting) and committed in ca0a548.

Mypy

⚠️ 2 pre-existing issues (not introduced by this PR's optimization logic):

• env_utils.py:35 — [unreachable]: else branch of isinstance(first_cmd, str) is dead code since formatter_cmds: list[str] guarantees first_cmd is always str. Original code had the same dead branch in ternary form.
• registry.py:60 — [no-redef]: _ import name reused across two contextlib.suppress blocks. Pre-existing pattern.

Code Review

3 inline comments posted:

File	Line(s)	Severity	Issue
registry.py	218	Low	Dead variable _ensure_called = False — assigned but never read
env_utils.py	57	Medium	except Exception should be except ImportError — overly broad catch silently swallows non-import errors
env_utils.py	29-35	Low	isinstance(first_cmd, str) check is always true; else branch is unreachable dead code

No critical bugs, security vulnerabilities, or breaking API changes found. The optimization logic (lazy import caching, fast-path string splitting, set intersection for formatter lookup, deferred _ensure_languages_registered()) is functionally sound.

Test Coverage

File	Stmts	Miss	Cover	Notes
codeflash/code_utils/env_utils.py	133	73	45%	Lines 52-93 (lazy import + formatter validation) uncovered
codeflash/languages/registry.py	149	33	78%	Lines 218-257 (get_language_support_by_common_formatters) uncovered

Changed lines coverage:

• check_formatter_installed fast-path split (lines 28-35): Partially covered (line 31 hit; lines 33-35 not hit)
• Lazy import caching (lines 50-63): ❌ Not covered
• get_language_support_by_common_formatters optimization (lines 217-257): ❌ Not covered by tests
• Framework aliases in get_language_support_by_framework (lines 283-291): ✅ Covered

The optimized functions themselves have low direct test coverage, though this is consistent with the pre-optimization state — these functions rely on integration/E2E tests that exercise them indirectly.

---

Last updated: 2026-02-20