⚡️ Speed up method Optimizer.get_optimizable_functions by 14% in PR #1869 (fix/trigger_cc_on_multiple_commits)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1869

If you approve this dependent PR, these changes will be merged into the original PR branch fix/trigger_cc_on_multiple_commits.

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

---

📄 14% (0.14x) speedup for Optimizer.get_optimizable_functions in codeflash/optimization/optimizer.py

⏱️ Runtime : 491 microseconds → 431 microseconds (best of 250 runs)

📝 Explanation and details

The remapping branch previously called mirror_path once per file and dataclasses.replace once per function, with each iteration incurring a repeated func.file_path.resolve() cost inside mirror_path. The optimized code resolves original_git_root and current_worktree exactly once before the loop, then computes relative_path directly via file_path.resolve().relative_to(original_root_resolved) and constructs new_path with simple path arithmetic (worktree_resolved / relative_path). Because all functions in a given funcs list share the same file_path, the list comprehension now does dataclasses.replace(func, file_path=new_path) with a pre‐computed new_path, eliminating redundant resolutions inside each function's replacement. Line profiler shows the mirror_path call dropped from 226 µs to 93 µs (with an additional 69 µs + 41 µs spent on the single upfront resolves), yielding a net 13% speedup. No regressions in correctness; all tests passed with timing deltas under 8%.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from argparse import Namespace
from pathlib import Path

import codeflash.discovery.functions_to_optimize as ftomodule
import codeflash.optimization.optimizer as optmodule

# imports
# Import the modules/classes we will exercise and monkeypatch
from codeflash.optimization.optimizer import Optimizer


def make_args(
    *,
    project_root: Path,
    module_root: Path,
    tests_root: Path,
    test_project_root: Path,
    all_flag: bool = False,
    file: Path | None = None,
    function: str | None = None,
    replay_test=None,
    ignore_paths=None,
    previous_checkpoint_functions=None,
    pytest_cmd: str | None = None,
):
    """Helper to construct a Namespace with the fields Optimizer expects.
    Keep minimal set of attributes required by Optimizer.__init__ and get_optimizable_functions call.
    """
    return Namespace(
        project_root=project_root,
        module_root=module_root,
        tests_root=tests_root,
        test_project_root=test_project_root,
        tests_root_arg=tests_root,  # irrelevant, but safe
        all=all_flag,
        file=file,
        function=function,
        replay_test=replay_test,
        ignore_paths=ignore_paths or [],
        previous_checkpoint_functions=previous_checkpoint_functions,
        pytest_cmd=pytest_cmd,
    )


def test_basic_calls_get_functions_to_optimize_without_remap():
    """Basic test:
    - Ensure Optimizer.get_optimizable_functions calls get_functions_to_optimize and returns its result
      when remapping is not requested (no current_worktree).
    - We monkeypatch ftomodule.get_functions_to_optimize to a simple function that returns a sentinel value.
    """
    # Save original so we can restore it later
    original_fn = ftomodule.get_functions_to_optimize
    try:
        called = {}

        # Define a fake get_functions_to_optimize that records what it was called with and returns a simple value
        def fake_get_functions_to_optimize(**kwargs):
            # Record relevant args for assertions
            called["kwargs"] = kwargs
            # Return a simple deterministic result: empty dict, zero count, no trace path
            return {}, 0, None

        # Monkeypatch the real function with our fake
        ftomodule.get_functions_to_optimize = fake_get_functions_to_optimize

        # Construct minimal args for the Optimizer
        args = make_args(
            project_root=Path("/proj"),
            module_root=Path("/proj/module"),
            tests_root=Path("/proj/tests"),
            test_project_root=Path("/proj"),
            all_flag=False,
        )

        opt = Optimizer(args)

        # No remapping branch: current_worktree is None by default so use_original_roots should be False
        result = opt.get_optimizable_functions()

        # Ensure result matches what fake returned
        assert result == ({}, 0, None), "Optimizer should return whatever get_functions_to_optimize returns"

        # Validate get_functions_to_optimize received expected keyword arguments
        assert "test_cfg" in called["kwargs"], "get_functions_to_optimize should be called with test_cfg"
        assert called["kwargs"]["optimize_all"] == args.all
        assert called["kwargs"]["file"] == args.file
        assert called["kwargs"]["only_get_this_function"] == args.function
        # Project/module roots passed should be the same as args.project_root/module_root
        assert called["kwargs"]["project_root"] == args.project_root
        assert called["kwargs"]["module_root"] == args.module_root

    finally:
        # Restore original function to avoid test pollution
        ftomodule.get_functions_to_optimize = original_fn


def test_remap_mode_uses_original_roots_and_calls_mirror_path():
    """Edge/basic test:
    - When Optimizer has current_worktree and original_args_and_test_cfg set, and args.all/file are falsy,
      the code goes into the remapping branch: it should call mirror_path for each returned file path.
    - We monkeypatch ftomodule.get_functions_to_optimize to return a mapping with a single file key (with empty func list),
      so dataclasses.replace is not exercised (empty comprehension), but mirror_path will be invoked for the file key.
    - Monkeypatch optimizer.git_root_dir and optimizer.mirror_path to record calls.
    """
    original_get_functions = ftomodule.get_functions_to_optimize
    original_git_root_dir = optmodule.git_root_dir
    original_mirror_path = optmodule.mirror_path

    try:
        # Prepare a fake result with one file path (list is empty to avoid dataclasses.replace being called)
        original_file = Path("/original_repo/src/file_a.py")
        fake_result = ({original_file: []}, 0, None)

        def fake_get_functions_to_optimize(**kwargs):
            # Return our prepared mapping regardless of inputs
            return fake_result

        # Track calls to git_root_dir and mirror_path
        calls = {"git_root_dir": 0, "mirror_path": []}

        def fake_git_root_dir(repo=None):
            calls["git_root_dir"] += 1
            return Path("/original_repo")

        def fake_mirror_path(path: Path, src_root: Path, dest_root: Path) -> Path:
            # Record arguments for inspection
            calls["mirror_path"].append((Path(path), Path(src_root), Path(dest_root)))
            # Produce a deterministic remapped path under dest_root
            relative = path.resolve().relative_to(src_root.resolve())
            return Path(dest_root) / relative

        # Apply monkeypatches
        ftomodule.get_functions_to_optimize = fake_get_functions_to_optimize
        optmodule.git_root_dir = fake_git_root_dir
        optmodule.mirror_path = fake_mirror_path

        # Build args and optimizer
        args = make_args(
            project_root=Path("/orig_project_root"),
            module_root=Path("/orig_module_root"),
            tests_root=Path("/proj/tests"),
            test_project_root=Path("/proj"),
            all_flag=False,
        )
        opt = Optimizer(args)

        # Simulate original args stored in optimizer so remapping branch becomes active
        original_args = Namespace(project_root=Path("/orig_project_root"), module_root=Path("/orig_module_root"))
        opt.original_args_and_test_cfg = (original_args, opt.test_cfg)
        opt.current_worktree = Path("/worktree")  # signal remapping should occur

        # Call the method under test
        remapped_result = opt.get_optimizable_functions()

        # Should have invoked git_root_dir once to find the original git repo root
        assert calls["git_root_dir"] == 1

        # mirror_path should have been called for the file key (even though funcs list empty)
        assert len(calls["mirror_path"]) == 1
        called_path, called_src_root, called_dest_root = calls["mirror_path"][0]
        assert called_path == original_file
        assert called_src_root == Path("/original_repo")
        assert called_dest_root == opt.current_worktree

        # Because our fake get_functions_to_optimize returned empty func lists, the remapped dict will be empty
        assert remapped_result == ({}, 0, None)

    finally:
        # Restore originals to avoid side-effects
        ftomodule.get_functions_to_optimize = original_get_functions
        optmodule.git_root_dir = original_git_root_dir
        optmodule.mirror_path = original_mirror_path

import tempfile
from argparse import Namespace
from pathlib import Path
from unittest.mock import patch

# imports
from codeflash.optimization.optimizer import Optimizer
from codeflash.verification.verification_utils import TestConfig


def test_get_optimizable_functions_returns_tuple_of_three():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        result = optimizer.get_optimizable_functions()  # 19.0μs -> 19.9μs (4.87% slower)

    assert isinstance(result, tuple), "Result should be a tuple"
    assert len(result) == 3, "Result should have exactly 3 elements"

    functions_dict, count, trace_path = result
    assert isinstance(functions_dict, dict), "First element should be a dict"
    assert isinstance(count, int), "Second element should be an int"
    assert trace_path is None or isinstance(trace_path, Path), "Third element should be None or Path"


def test_get_optimizable_functions_with_all_parameter():
    temp_dir = Path(tempfile.gettempdir()) / "test_codeflash_all"
    temp_dir.mkdir(exist_ok=True)

    args = Namespace(
        all=str(temp_dir),
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=temp_dir,
        module_root=temp_dir,
        tests_root=temp_dir / "tests",
        test_project_root=temp_dir,
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 17.4μs -> 18.3μs (4.66% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["optimize_all"] == str(temp_dir)
    assert call_kwargs["replay_test"] is None
    assert call_kwargs["file"] is None


def test_get_optimizable_functions_with_file_parameter():
    temp_file = Path(tempfile.gettempdir()) / "test_file.py"
    temp_file.touch()

    args = Namespace(
        all=None,
        replay_test=None,
        file=str(temp_file),
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 16.5μs -> 17.1μs (3.97% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["file"] == str(temp_file)


def test_get_optimizable_functions_returns_correct_count():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 42, None)
        _, count, _ = optimizer.get_optimizable_functions()  # 16.4μs -> 17.0μs (3.24% slower)

    assert count == 42, "Count should match the mocked value"


def test_get_optimizable_functions_passes_ignore_paths():
    ignore_path = Path.cwd() / "vendor"
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[ignore_path],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 16.4μs -> 16.5μs (0.848% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["ignore_paths"] == [ignore_path]


def test_get_optimizable_functions_passes_test_config():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 16.3μs -> 17.4μs (6.56% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    test_cfg = call_kwargs["test_cfg"]
    assert isinstance(test_cfg, TestConfig)
    assert test_cfg.project_root_path == args.project_root


def test_get_optimizable_functions_with_empty_ignore_paths():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        _, count, _ = optimizer.get_optimizable_functions()  # 16.3μs -> 16.2μs (0.680% faster)

    assert count == 0


def test_get_optimizable_functions_with_none_previous_checkpoint():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 15.8μs -> 16.0μs (1.38% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["previous_checkpoint_functions"] is None


def test_get_optimizable_functions_with_previous_checkpoint_dict():
    checkpoint_funcs = {"module.func": {"key": "value"}}
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=checkpoint_funcs,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 15.9μs -> 16.0μs (0.437% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["previous_checkpoint_functions"] == checkpoint_funcs


def test_get_optimizable_functions_with_since_commit():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit="abc123def456",
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 15.8μs -> 16.0μs (1.32% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["since_commit"] == "abc123def456"


def test_get_optimizable_functions_without_since_commit():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 15.9μs -> 15.9μs (0.063% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["since_commit"] is None


def test_get_optimizable_functions_with_trace_path():
    trace_file = Path.cwd() / "trace.pkl"
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, trace_file)
        _, _, returned_trace = optimizer.get_optimizable_functions()  # 15.4μs -> 16.6μs (7.31% slower)

    assert returned_trace == trace_file


def test_get_optimizable_functions_with_empty_functions_dict():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        funcs_dict, count, trace = optimizer.get_optimizable_functions()  # 16.0μs -> 15.9μs (0.566% faster)

    assert funcs_dict == {}
    assert count == 0
    assert trace is None


def test_get_optimizable_functions_with_multiple_ignore_paths():
    ignore_paths = [Path.cwd() / "vendor", Path.cwd() / ".git", Path.cwd() / "node_modules"]
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=ignore_paths,
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 15.9μs -> 15.8μs (0.888% faster)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["ignore_paths"] == ignore_paths


def test_get_optimizable_functions_preserves_project_root():
    project_root = Path.cwd() / "my_project"
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=project_root,
        module_root=project_root / "src",
        tests_root=project_root / "tests",
        test_project_root=project_root,
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 16.1μs -> 15.9μs (1.25% faster)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["project_root"] == project_root


def test_get_optimizable_functions_with_many_ignore_paths():
    ignore_paths = [Path.cwd() / f"ignore_{i}" for i in range(100)]
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=ignore_paths,
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 17.2μs -> 17.3μs (0.579% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert len(call_kwargs["ignore_paths"]) == 100


def test_get_optimizable_functions_with_large_function_count():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 500, None)
        _, count, _ = optimizer.get_optimizable_functions()  # 16.6μs -> 17.0μs (2.30% slower)

    assert count == 500


def test_get_optimizable_functions_with_large_checkpoint_dict():
    checkpoint_funcs = {f"module{i}.func{i}": {"key": f"value{i}"} for i in range(1000)}
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=checkpoint_funcs,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 18.2μs -> 17.9μs (1.63% faster)

    call_kwargs = mock_get_funcs.call_args[1]
    assert len(call_kwargs["previous_checkpoint_functions"]) == 1000


def test_get_optimizable_functions_multiple_calls_consistency():
    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=Path.cwd(),
        module_root=Path.cwd(),
        tests_root=Path.cwd() / "tests",
        test_project_root=Path.cwd(),
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        return_values = [
            ({}, 10, None),
            ({}, 25, Path.cwd() / "trace1.pkl"),
            ({}, 5, None),
            ({}, 100, Path.cwd() / "trace2.pkl"),
            ({}, 42, None),
            ({}, 7, Path.cwd() / "trace3.pkl"),
            ({}, 88, None),
            ({}, 15, None),
            ({}, 33, Path.cwd() / "trace4.pkl"),
            ({}, 50, None),
        ]
        mock_get_funcs.side_effect = return_values

        counts_received = []
        for expected_funcs, expected_count, expected_trace in return_values:
            funcs_dict, count, trace = optimizer.get_optimizable_functions()
            counts_received.append(count)
            assert funcs_dict == expected_funcs
            assert count == expected_count
            assert trace == expected_trace

        assert counts_received == [10, 25, 5, 100, 42, 7, 88, 15, 33, 50]
        assert mock_get_funcs.call_count == 10


def test_get_optimizable_functions_different_module_roots():
    project_root = Path.cwd()
    module_root = Path.cwd() / "src" / "submodule"

    args = Namespace(
        all=None,
        replay_test=None,
        file=None,
        function=None,
        ignore_paths=[],
        project_root=project_root,
        module_root=module_root,
        tests_root=project_root / "tests",
        test_project_root=project_root,
        pytest_cmd="pytest",
        previous_checkpoint_functions=None,
        since_commit=None,
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 0, None)
        optimizer.get_optimizable_functions()  # 16.8μs -> 16.9μs (0.468% slower)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["project_root"] == project_root
    assert call_kwargs["module_root"] == module_root


def test_get_optimizable_functions_all_parameters_passed_correctly():
    ignore_paths = [Path.cwd() / "vendor", Path.cwd() / "dist"]
    checkpoint_funcs = {"func1": {"status": "done"}, "func2": {"status": "pending"}}
    trace_file = Path.cwd() / "trace.pkl"

    args = Namespace(
        all="my_project",
        replay_test=None,
        file=None,
        function="my_function",
        ignore_paths=ignore_paths,
        project_root=Path.cwd() / "project",
        module_root=Path.cwd() / "project" / "src",
        tests_root=Path.cwd() / "project" / "tests",
        test_project_root=Path.cwd() / "project",
        pytest_cmd="pytest",
        previous_checkpoint_functions=checkpoint_funcs,
        since_commit="abc123",
    )
    optimizer = Optimizer(args)

    with patch("codeflash.discovery.functions_to_optimize.get_functions_to_optimize") as mock_get_funcs:
        mock_get_funcs.return_value = ({}, 5, trace_file)
        funcs_dict, count, trace = optimizer.get_optimizable_functions()  # 16.8μs -> 16.3μs (3.32% faster)

    call_kwargs = mock_get_funcs.call_args[1]
    assert call_kwargs["optimize_all"] == "my_project"
    assert call_kwargs["replay_test"] is None
    assert call_kwargs["file"] is None
    assert call_kwargs["only_get_this_function"] == "my_function"
    assert call_kwargs["ignore_paths"] == ignore_paths
    assert call_kwargs["project_root"] == Path.cwd() / "project"
    assert call_kwargs["module_root"] == Path.cwd() / "project" / "src"
    assert call_kwargs["previous_checkpoint_functions"] == checkpoint_funcs
    assert call_kwargs["since_commit"] == "abc123"
    assert count == 5
    assert trace == trace_file

To edit these changes git checkout codeflash/optimize-pr1869-2026-03-18T20.01.48 and push.

[claude]

Claude finished @codeflash-ai[bot]'s task in 2m 3s —— View job

---

PR Review Summary

• Triage PR scope
• Lint and typecheck
• Resolve stale threads
• Code review
• Duplicate detection
• Test coverage
• Check optimization PRs

---

Prek Checks

ruff check and ruff format both passed. No issues found.

Code Review

Bug Fixed: Duplicate comment block ✅

The optimization PR accidentally duplicated the existing comment block (lines 136–144 of optimizer.py) — the 4-line comment explaining worktree mode appeared twice in a row. I removed the duplicate and pushed the fix.

Optimization correctness:

The core change inlines mirror_path with pre-resolved roots:

# Before (per-iteration resolve inside mirror_path):
new_path = mirror_path(Path(file_path), original_git_root, self.current_worktree)
remapped[new_path] = [dataclasses.replace(func, file_path=mirror_path(func.file_path, ...)) for func in funcs]

# After (resolve once, reuse):
original_root_resolved = original_git_root.resolve()
worktree_resolved = self.current_worktree.resolve()
relative_path = file_path.resolve().relative_to(original_root_resolved)
new_path = worktree_resolved / relative_path
remapped[new_path] = [dataclasses.replace(func, file_path=new_path) for func in funcs]

This is semantically equivalent to mirror_path (git_utils.py:153-155) which does path.resolve().relative_to(src_root.resolve()). One subtle behavioral difference: the old code called mirror_path(func.file_path, ...) independently per function, while the new code reuses new_path (from the dict key) for all functions in a file's list. This is correct since all functions under a dict key share that file path, but slightly changes semantics if func.file_path ever diverged from the key — not a concern in practice.

Duplicate Detection

No duplicates detected. The inlined path-computation logic replaces calls to mirror_path rather than duplicating it elsewhere.

Test Coverage

55 generated regression tests passed (100% coverage per PR report). No existing unit tests to compare against for this method.

---

Fix committed: Removed duplicate comment block → 71ab1dbf
| Branch

[claude]

Closing: CI unit tests are failing on the base branch (tests/test_git_utils.py::TestGetGitDiffMultiLanguage::test_java_diff_ignored_when_language_is_python and test_mixed_lang_diff_filters_by_current_language). These failures appear to be pre-existing on the fix/trigger_cc_on_multiple_commits branch and cannot be auto-fixed.