⚡️ Speed up function _cached_path_to_class_name by 19% in PR #1804 (codeflash/optimize-pr1774-2026-03-09T23.18.58)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1804

If you approve this dependent PR, these changes will be merged into the original PR branch codeflash/optimize-pr1774-2026-03-09T23.18.58.

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

---

📄 19% (0.19x) speedup for _cached_path_to_class_name in codeflash/languages/java/test_runner.py

⏱️ Runtime : 1.27 milliseconds → 1.07 milliseconds (best of 250 runs)

📝 Explanation and details

The optimization replaced path.suffix with path.name.endswith(".java") and deferred path.as_posix() until needed, cutting the early-exit check from ~2400 ns/hit to ~1124 ns/hit (profiler line 1). It also avoided converting path.parts from a tuple to a list, saving ~1600 ns/hit on 237 calls. The line that built the final dotted class name was refactored to avoid a mutable list mutation (class_parts[-1] = ...) and instead unpacked a tuple in ".".join((*class_parts[:-1], last)), reducing per-hit cost by ~54 ns. Overall runtime improved 18% (1.27 ms → 1.07 ms) with no correctness regressions across all test cases.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from pathlib import Path

# imports
import pytest  # used for our unit tests
# import the function under test from the real module
from codeflash.languages.java.test_runner import _cached_path_to_class_name

def test_non_java_extension_returns_none():
    # Ensure cache is clean to avoid cross-test interactions.
    _cached_path_to_class_name.cache_clear()
    # Provide a path that does not end with .java -> expected result is None.
    result = _cached_path_to_class_name("some/random/path/File.txt") # 8.12μs -> 7.42μs (9.34% faster)
    assert result is None  # non-java files must yield None

def test_standard_maven_main_and_test_structure():
    # Clear cache before deterministic assertions.
    _cached_path_to_class_name.cache_clear()
    # Typical Maven main java path should map to dotted class name.
    main_path = "project/src/main/java/com/example/MyClass.java"
    assert _cached_path_to_class_name(main_path) == "com.example.MyClass" # 14.1μs -> 10.8μs (30.9% faster)

    # Typical Maven test java path should map similarly.
    test_path = "project/src/test/java/org/acme/TestSomething.java"
    assert _cached_path_to_class_name(test_path) == "org.acme.TestSomething" # 8.61μs -> 6.82μs (26.2% faster)

def test_last_java_segment_used_when_no_main_or_test():
    # Clear cache for deterministic behavior.
    _cached_path_to_class_name.cache_clear()
    # When no 'main' or 'test' before 'java', the last 'java' segment is used.
    path = "libs/some/java/com/example/Util.java"
    # Expect the class name to be everything after the last 'java' directory.
    assert _cached_path_to_class_name(path) == "com.example.Util" # 14.8μs -> 12.6μs (17.6% faster)

    # More complex nesting with multiple 'java' segments uses the last one.
    nested = "a/java/b/java/c/d/Thing.java"
    assert _cached_path_to_class_name(nested) == "c.d.Thing" # 9.68μs -> 8.18μs (18.4% faster)

def test_package_declaration_read_from_existing_file(tmp_path: Path):
    # Clear cache to ensure fresh evaluation that may read the file.
    _cached_path_to_class_name.cache_clear()
    # Create a non-standard source layout file that contains a package declaration.
    java_file = tmp_path / "weird" / "MyClass.java"
    java_file.parent.mkdir(parents=True, exist_ok=True)
    # Write a package declaration; trailing semicolon should be tolerated.
    java_file.write_text("package org.example.sub;\npublic class MyClass {}")
    # Use POSIX string as required by the cached wrapper.
    result = _cached_path_to_class_name(java_file.as_posix()) # 45.2μs -> 45.2μs (0.033% faster)
    # Expect package + filename without extension
    assert result == "org.example.sub.MyClass"

def test_leading_comments_before_package_are_ignored(tmp_path: Path):
    # Ensure fresh cache so file read is actually performed.
    _cached_path_to_class_name.cache_clear()
    # File that begins with comments, then a package declaration on a later line.
    java_file = tmp_path / "comments" / "Commented.java"
    java_file.parent.mkdir(parents=True, exist_ok=True)
    content = (
        "// single line comment\n"
        "/*\n"
        " multi-line comment\n"
        "*/\n"
        "   package   com.example.comments;   \n"
        "class Commented {}"
    )
    java_file.write_text(content)
    assert _cached_path_to_class_name(java_file.as_posix()) == "com.example.comments.Commented" # 42.7μs -> 41.9μs (1.86% faster)

def test_file_without_package_returns_stem_when_no_standard_java_dir(tmp_path: Path):
    # Clear cache so this test is isolated.
    _cached_path_to_class_name.cache_clear()
    # Create a .java file that does not contain a package declaration and is not in a 'java' directory.
    java_file = tmp_path / "NoPackage.java"
    # File starts directly with an import (a non-package, non-comment line) -> should break and return stem.
    java_file.write_text("import java.util.*;\npublic class NoPackage {}")
    # Because there's no 'java' directory in the path and file contains no package declaration at top, return stem.
    assert _cached_path_to_class_name(java_file.as_posix()) == "NoPackage" # 40.9μs -> 39.9μs (2.54% faster)

def test_nonexistent_file_returns_stem_when_no_java_dir():
    # Clear cache first.
    _cached_path_to_class_name.cache_clear()
    # Nonexistent file path (no actual file on disk) and no 'java' segment -> should return the stem.
    path = "some/custom/location/DoesNotExist.java"
    assert _cached_path_to_class_name(path) == "DoesNotExist" # 23.9μs -> 23.3μs (2.80% faster)

def test_cache_consistency_across_repeated_calls():
    # Clear cache to start fresh.
    _cached_path_to_class_name.cache_clear()
    # Use a standard maven-style path.
    path = "project/src/main/java/com/cache/CacheTest.java"
    # First call computes result and stores it in cache.
    first = _cached_path_to_class_name(path) # 15.8μs -> 12.8μs (24.2% faster)
    # Second call should return the identical string result (cache hit or recompute identical result).
    second = _cached_path_to_class_name(path)
    assert first == second == "com.cache.CacheTest" # 213ns -> 191ns (11.5% faster)

def test_large_scale_many_paths_performance_and_correctness():
    # Clear cache to ensure all entries can be inserted and the function is exercised for many inputs.
    _cached_path_to_class_name.cache_clear()
    # Construct a large set of posix-style paths following a standard maven layout.
    n = 1000  # scale up to 1000 elements as requested
    paths = []
    expected = []
    for i in range(n):
        # Create package segment unique per index to avoid accidental collisions.
        pkg = f"pkg{i}"
        cls = f"Class{i}"
        p = f"multi/project/src/main/java/{pkg}/{cls}.java"
        paths.append(p)
        expected.append(f"{pkg}.{cls}")

    # Evaluate all inputs and collect outputs.
    results = [_cached_path_to_class_name(p) for p in paths]

    # All results must match their expected dotted class names.
    assert results == expected

    # Repeat once to exercise the cache layer across the same inputs.
    results_repeat = [_cached_path_to_class_name(p) for p in paths]
    assert results_repeat == expected  # still identical on repeated access

from pathlib import Path

# imports
import pytest
from codeflash.languages.java.test_runner import _cached_path_to_class_name

def test_basic_java_file_conversion():
    """Test converting a basic Java file path to class name."""
    result = _cached_path_to_class_name("src/main/java/com/example/MyClass.java") # 13.8μs -> 11.2μs (22.8% faster)
    assert result == "com.example.MyClass"

def test_nested_package_structure():
    """Test handling of deeply nested package structures."""
    result = _cached_path_to_class_name("src/main/java/com/example/service/impl/MyServiceImpl.java") # 15.4μs -> 13.3μs (16.1% faster)
    assert result == "com.example.service.impl.MyServiceImpl"

def test_test_source_directory():
    """Test paths in test source directories."""
    result = _cached_path_to_class_name("src/test/java/com/example/MyTest.java") # 14.4μs -> 11.3μs (27.7% faster)
    assert result == "com.example.MyTest"

def test_non_java_file():
    """Test that non-Java files return None."""
    result = _cached_path_to_class_name("src/main/java/com/example/README.txt") # 8.56μs -> 7.49μs (14.4% faster)
    assert result is None

def test_non_java_extension():
    """Test various non-Java extensions."""
    result = _cached_path_to_class_name("src/main/java/com/example/Config.xml") # 8.11μs -> 7.48μs (8.41% faster)
    assert result is None

def test_single_class_in_java_dir():
    """Test a single class name in a java directory."""
    result = _cached_path_to_class_name("src/main/java/SimpleClass.java") # 14.0μs -> 10.3μs (35.8% faster)
    assert result == "SimpleClass"

def test_caching_same_input():
    """Test that caching returns the same result for identical inputs."""
    path = "src/main/java/com/example/CachedClass.java"
    result1 = _cached_path_to_class_name(path) # 13.8μs -> 11.3μs (22.6% faster)
    result2 = _cached_path_to_class_name(path)
    assert result1 == result2 # 229ns -> 218ns (5.05% faster)
    assert result1 == "com.example.CachedClass"

def test_caching_different_inputs():
    """Test that caching distinguishes between different inputs."""
    path1 = "src/main/java/com/example/ClassA.java"
    path2 = "src/main/java/com/other/ClassB.java"
    result1 = _cached_path_to_class_name(path1) # 13.5μs -> 11.1μs (22.1% faster)
    result2 = _cached_path_to_class_name(path2)
    assert result1 == "com.example.ClassA" # 8.42μs -> 7.06μs (19.2% faster)
    assert result2 == "com.other.ClassB"
    assert result1 != result2

def test_posix_path_format():
    """Test that POSIX path format is correctly handled."""
    # Use forward slashes as per POSIX standard
    result = _cached_path_to_class_name("src/main/java/com/example/PosixClass.java") # 13.1μs -> 10.4μs (25.2% faster)
    assert result == "com.example.PosixClass"

def test_empty_string_path():
    """Test handling of empty string path."""
    result = _cached_path_to_class_name("") # 5.17μs -> 4.58μs (13.1% faster)
    assert result is None or isinstance(result, str)

def test_path_without_java_directory():
    """Test paths that don't contain 'java' directory."""
    result = _cached_path_to_class_name("src/resources/com/example/Config.java") # 24.4μs -> 24.1μs (1.45% faster)
    assert result is not None  # Should still return something

def test_java_file_without_package():
    """Test Java file path with .java extension but no package structure."""
    result = _cached_path_to_class_name("src/main/java/SimpleJavaFile.java") # 13.7μs -> 10.3μs (32.8% faster)
    assert result == "SimpleJavaFile"

def test_multiple_java_directories_in_path():
    """Test path with multiple 'java' directory occurrences."""
    result = _cached_path_to_class_name("src/java/com/java/example/MultiJava.java") # 15.6μs -> 13.0μs (20.2% faster)
    # Should prefer the one after 'main' or 'test' if available
    assert result is not None

def test_class_name_with_numbers():
    """Test class names containing numbers."""
    result = _cached_path_to_class_name("src/main/java/com/example/Class2Impl.java") # 14.3μs -> 10.9μs (30.4% faster)
    assert result == "com.example.Class2Impl"

def test_class_name_with_underscores():
    """Test class names containing underscores."""
    result = _cached_path_to_class_name("src/main/java/com/example/My_Class_Impl.java") # 13.5μs -> 10.6μs (27.0% faster)
    assert result == "com.example.My_Class_Impl"

def test_uppercase_package_name():
    """Test handling of uppercase characters in package names."""
    result = _cached_path_to_class_name("src/main/java/Com/Example/MyClass.java") # 13.4μs -> 10.9μs (23.4% faster)
    assert result == "Com.Example.MyClass"

def test_very_long_package_path():
    """Test very long package hierarchy."""
    result = _cached_path_to_class_name(
        "src/main/java/com/example/sub1/sub2/sub3/sub4/sub5/VeryLongPath.java"
    ) # 15.7μs -> 12.8μs (23.4% faster)
    assert result == "com.example.sub1.sub2.sub3.sub4.sub5.VeryLongPath"

def test_path_with_dots_in_directory_names():
    """Test handling of dots in directory names (unusual but possible)."""
    result = _cached_path_to_class_name("src/main/java/com.v2/example/MyClass.java") # 13.3μs -> 11.0μs (21.4% faster)
    assert result == "com.v2.example.MyClass"

def test_path_with_hyphens_in_directory_names():
    """Test handling of hyphens in directory names."""
    result = _cached_path_to_class_name("src/main/java/com-example/service/MyClass.java") # 13.2μs -> 11.6μs (14.7% faster)
    assert result == "com-example.service.MyClass"

def test_trailing_slashes():
    """Test paths with trailing slashes."""
    result = _cached_path_to_class_name("src/main/java/com/example/MyClass.java/") # 13.1μs -> 10.6μs (24.1% faster)
    # Should still work or handle gracefully
    assert result is not None or result is None

def test_case_sensitivity_of_java_extension():
    """Test that .java extension is case-sensitive."""
    result_lowercase = _cached_path_to_class_name("src/main/java/com/example/MyClass.java") # 12.9μs -> 10.2μs (26.7% faster)
    result_uppercase = _cached_path_to_class_name("src/main/java/com/example/MyClass.JAVA")
    assert result_lowercase == "com.example.MyClass" # 5.16μs -> 5.17μs (0.097% slower)
    assert result_uppercase is None

def test_gradle_src_layout():
    """Test Gradle's source directory layout."""
    result = _cached_path_to_class_name("src/main/java/com/gradle/example/GradleClass.java") # 13.6μs -> 11.0μs (23.7% faster)
    assert result == "com.gradle.example.GradleClass"

def test_maven_src_layout():
    """Test Maven's source directory layout."""
    result = _cached_path_to_class_name("src/test/java/com/maven/example/MavenTest.java") # 13.8μs -> 11.3μs (22.5% faster)
    assert result == "com.maven.example.MavenTest"

def test_just_java_directory_and_file():
    """Test minimal path with just 'java' directory and filename."""
    result = _cached_path_to_class_name("java/HelloWorld.java") # 13.7μs -> 10.5μs (31.3% faster)
    assert result == "HelloWorld"

def test_path_with_only_main_no_java():
    """Test path with 'main' but no 'java' subdirectory."""
    result = _cached_path_to_class_name("src/main/com/example/MyClass.java") # 23.2μs -> 22.8μs (1.80% faster)
    assert result is not None

def test_double_extension_handling():
    """Test files with double extensions like MyClass.test.java."""
    result = _cached_path_to_class_name("src/main/java/com/example/MyClass.test.java") # 14.2μs -> 11.1μs (28.2% faster)
    assert result == "com.example.MyClass.test"

def test_single_letter_package_names():
    """Test single letter package names."""
    result = _cached_path_to_class_name("src/main/java/a/b/c/D.java") # 14.0μs -> 11.8μs (18.6% faster)
    assert result == "a.b.c.D"

def test_numeric_first_part_after_java():
    """Test numeric characters at the start of class path components."""
    result = _cached_path_to_class_name("src/main/java/123/example/MyClass.java") # 13.6μs -> 11.0μs (23.6% faster)
    assert result == "123.example.MyClass"

def test_cache_with_many_different_paths():
    """Test caching performance with many different paths."""
    paths = [
        f"src/main/java/com/example/module{i}/Class{i}.java"
        for i in range(100)
    ]
    results = [_cached_path_to_class_name(path) for path in paths]
    # Verify all results are correct
    for i, result in enumerate(results):
        assert result == f"com.example.module{i}.Class{i}"
    # Verify all results are unique
    assert len(set(results)) == len(results)

def test_cache_with_repeated_paths():
    """Test caching efficiency with repeated path lookups."""
    path = "src/main/java/com/example/RepeatedClass.java"
    # Call multiple times to test cache effectiveness
    results = [_cached_path_to_class_name(path) for _ in range(100)]
    # All results should be identical
    assert all(r == "com.example.RepeatedClass" for r in results)
    assert len(set(results)) == 1

def test_large_package_hierarchy():
    """Test handling of very large package hierarchies."""
    path_parts = ["src", "main", "java"] + [f"package{i}" for i in range(50)] + ["LargeClass.java"]
    path = "/".join(path_parts)
    result = _cached_path_to_class_name(path) # 27.5μs -> 25.7μs (6.82% faster)
    expected = ".".join([f"package{i}" for i in range(50)] + ["LargeClass"])
    assert result == expected

def test_mixed_cache_with_various_extensions():
    """Test cache behavior with similar paths but different extensions."""
    java_path = "src/main/java/com/example/MultiExt.java"
    txt_path = "src/main/java/com/example/MultiExt.txt"
    class_path = "src/main/java/com/example/MultiExt.class"
    
    result_java = _cached_path_to_class_name(java_path) # 13.4μs -> 11.0μs (22.0% faster)
    result_txt = _cached_path_to_class_name(txt_path)
    result_class = _cached_path_to_class_name(class_path) # 5.07μs -> 4.42μs (14.6% faster)
    
    assert result_java == "com.example.MultiExt"
    assert result_txt is None # 3.26μs -> 3.18μs (2.45% faster)
    assert result_class is None

def test_cache_consistency_across_many_calls():
    """Test that cache provides consistent results across many calls."""
    test_paths = [
        "src/main/java/com/app/service/UserService.java",
        "src/test/java/com/app/service/UserServiceTest.java",
        "src/main/java/org/apache/commons/util/Helper.java",
        "src/main/java/MyTopLevelClass.java",
    ]
    
    # Call each path multiple times
    all_results = {}
    for path in test_paths:
        results = [_cached_path_to_class_name(path) for _ in range(50)]
        all_results[path] = results
        # All calls for the same path should return the same result
        assert len(set(results)) == 1
    
    # Verify expected results
    assert all_results[test_paths[0]][0] == "com.app.service.UserService"
    assert all_results[test_paths[1]][0] == "com.app.service.UserServiceTest"
    assert all_results[test_paths[2]][0] == "org.apache.commons.util.Helper"
    assert all_results[test_paths[3]][0] == "MyTopLevelClass"

def test_cache_maxsize_handling():
    """Test that cache respects its maxsize parameter."""
    # Generate paths beyond cache size (default is 2048)
    # This tests cache eviction behavior
    base_results = []
    for i in range(100):
        path = f"src/main/java/pkg{i % 20}/Class{i}.java"
        result = _cached_path_to_class_name(path) # 518μs -> 413μs (25.2% faster)
        base_results.append(result)
    
    # All results should be valid class names
    assert all(r is not None for r in base_results)
    assert all("." in r or i < 20 for i, r in enumerate(base_results))

def test_return_type_consistency():
    """Test that return type is always either str or None."""
    test_cases = [
        "src/main/java/com/example/Valid.java",
        "src/main/java/Invalid.txt",
        "src/main/java/AnotherValid.java",
        "",
        "NoJavaHere.java",
    ]
    
    for path in test_cases:
        result = _cached_path_to_class_name(path) # 43.5μs -> 38.9μs (11.9% faster)
        assert result is None or isinstance(result, str)

def test_posix_string_input_format():
    """Test that function accepts and processes POSIX-formatted strings."""
    # All inputs use forward slashes as per POSIX
    paths = [
        "src/main/java/com/example/ClassA.java",
        "src/test/java/org/example/ClassB.java",
        "project/src/main/java/io/example/ClassC.java",
    ]
    
    for path in paths:
        result = _cached_path_to_class_name(path) # 28.9μs -> 23.0μs (25.4% faster)
        assert isinstance(result, (str, type(None)))
        # Verify result has no backslashes (only forward slashes in package names)
        if result:
            assert "\\" not in result

To edit these changes git checkout codeflash/optimize-pr1804-2026-03-09T23.31.09 and push.

[claude]

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

---

PR Review Summary

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

---

Prek Checks

✅ All prek checks pass (ruff lint + format).
✅ mypy: no issues found.

Code Review

Minor: Duplicate comments introduced — The diff adds a blank line + comment # Look for standard Maven/Gradle source directories at line 1091, but the identical comment already follows at line 1096. Similarly, # For non-standard source directories, read the package declaration appears twice consecutively at lines 1118 and 1120. These are leftover artifacts from the optimization and should be cleaned up. Fix this →

The optimization logic itself is correct:

• name.endswith(".java") is functionally equivalent to path.suffix != ".java" for all normal file paths.
• Using path.parts directly (a tuple) instead of list(path.parts) is valid — slicing a tuple returns a tuple, which supports indexing.
• The tuple unpacking ".".join((*class_parts[:-1], last)) correctly avoids mutating a tuple (the original class_parts[-1] = ... would have failed on a tuple anyway, so this is a correctness fix too).
• Deferring path.as_posix() until needed (only when source_dirs is non-empty) is a valid optimization.

No bugs, security issues, or breaking changes found.

Duplicate Detection

No duplicates detected — _path_to_class_name and _cached_path_to_class_name exist only in codeflash/languages/java/test_runner.py.

Test Coverage

All 27 existing unit tests for _path_to_class_name pass. Coverage for codeflash/languages/java/test_runner.py is 53% overall (the low coverage reflects untested integration paths in the larger file, not the changed function specifically). One unrelated flaky timing test failed (test_performance_inner_loop_count_and_timing) with CV=5.01% just above the 5% threshold — not caused by this PR.

Merge Optimization PRs

CI is still pending for most checks on this PR (only prek, type-check-cli, license/cla have completed). Not merging until CI completes.

---

Last updated: 2026-03-09