⚡️ Speed up method JavaImportResolver.resolve_imports by 13% 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.

---

📄 13% (0.13x) speedup for JavaImportResolver.resolve_imports in codeflash/languages/java/import_resolver.py

⏱️ Runtime : 6.17 milliseconds → 5.44 milliseconds (best of 107 runs)

📝 Explanation and details

The optimized code achieves a 13% runtime improvement (from 6.17ms to 5.44ms) by eliminating redundant work in the resolve_import method through two key optimizations:

1. Hoisting _extract_class_name computation:
The original code called self._extract_class_name(import_path) three times—once in each of the two early-return branches (standard library and external library) and once in the final return statement. The optimized version computes the class name once at the start of the method and reuses the result across all code paths. This eliminates 2 out of 3 calls for imports that match standard or external libraries (which represent the majority of imports in typical Java projects).

From the line profiler data, the original code spent ~4.28 million nanoseconds across three separate _extract_class_name calls (lines with 2.44M + 815K + 1.02M). The optimized version consolidates this into a single 4.39M nanosecond call, reducing overhead from repeated function invocations, string operations (rpartition), and character checks (isupper).

2. Merging identical early-return branches:
The original code had two nearly identical if blocks that both returned ResolvedImport objects with file_path=None and is_external=True. The optimized version combines these into a single conditional using or, reducing:

• Duplicate ResolvedImport object construction
• Redundant attribute assignments
• Code branching overhead

The line profiler shows this consolidation reduces the total time spent in the conditional checks and return statements. The optimized version's combined branch (line spending 16.1M ns) is faster than the sum of the original's two separate branches (11.5M + 7.0M = 18.5M ns).

Impact on workloads:
This optimization particularly benefits codebases with many standard library and external dependency imports (the most common scenario), as these hit the now-consolidated early-return path. The test results show consistent speedups across all test cases, with the largest gains in tests involving large batches of standard/external imports (e.g., test_resolve_imports_large_batch_all_standard_packages and test_resolve_imports_large_batch_all_common_external_packages), where the class name extraction savings multiply across hundreds of imports.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from pathlib import Path
from unittest.mock import MagicMock, patch

import pytest
from codeflash.languages.java.import_resolver import JavaImportResolver
from codeflash.languages.java.parser import JavaImportInfo

def test_resolve_imports_empty_list():
    """Test that resolve_imports handles an empty list of imports."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                codeflash_output = resolver.resolve_imports([]); result = codeflash_output

def test_resolve_imports_single_standard_library_import():
    """Test resolving a single standard Java library import (java.util.List)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="java.util.List",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_single_external_library_import():
    """Test resolving a single external library import (org.junit.Test)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.junit.Test",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_multiple_mixed_imports():
    """Test resolving multiple imports of different types (standard, external, local)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                imports = [
                    JavaImportInfo(
                        import_path="java.util.ArrayList",
                        is_static=False,
                        is_wildcard=False,
                        start_line=1,
                        end_line=1
                    ),
                    JavaImportInfo(
                        import_path="org.springframework.Boot",
                        is_static=False,
                        is_wildcard=False,
                        start_line=2,
                        end_line=2
                    ),
                ]
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output

def test_resolve_imports_wildcard_import():
    """Test resolving a wildcard import (java.util.*)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="java.util",
                    is_static=False,
                    is_wildcard=True,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_static_import():
    """Test resolving a static import (java.lang.Math.PI)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="java.lang.Math",
                    is_static=True,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_with_lowercase_package_name():
    """Test that class names starting with lowercase are not extracted (e.g., package names)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.example.utils",
                    is_static=False,
                    is_wildcard=True,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_with_empty_import_path():
    """Test handling of an empty import path."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_with_single_component_import():
    """Test handling of single-component imports (just a class name)."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="String",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_javax_package():
    """Test that javax packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="javax.xml.parsers.SAXParser",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_sun_package():
    """Test that sun packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="sun.misc.Unsafe",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_com_sun_package():
    """Test that com.sun packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.sun.jna.Native",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_jdk_package():
    """Test that jdk packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="jdk.nashorn.api.scripting.ClassFilter",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_w3c_package():
    """Test that org.w3c packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.w3c.dom.Document",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_xml_package():
    """Test that org.xml packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.xml.sax.SAXException",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_ietf_package():
    """Test that org.ietf packages are recognized as standard library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.ietf.jgss.GSSContext",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_junit_package():
    """Test that org.junit packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.junit.jupiter.api.Test",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_mockito_package():
    """Test that org.mockito packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.mockito.Mockito",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_assertj_package():
    """Test that org.assertj packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.assertj.core.api.Assertions",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_hamcrest_package():
    """Test that org.hamcrest packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.hamcrest.Matchers",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_slf4j_package():
    """Test that org.slf4j packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.slf4j.Logger",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_apache_package():
    """Test that org.apache packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.apache.commons.lang.StringUtils",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_org_springframework_package():
    """Test that org.springframework packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="org.springframework.boot.Application",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_com_google_package():
    """Test that com.google packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.google.common.collect.Lists",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_com_fasterxml_package():
    """Test that com.fasterxml packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.fasterxml.jackson.databind.ObjectMapper",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_io_netty_package():
    """Test that io.netty packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="io.netty.channel.Channel",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_io_github_package():
    """Test that io.github packages are recognized as external libraries."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="io.github.cdimascio.dotenv.Dotenv",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_lombok_package():
    """Test that lombok package is recognized as an external library."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="lombok.Data",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_very_long_import_path():
    """Test handling of very long import paths."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                long_path = "com.example.very.long.nested.package.structure.with.many.levels.MyClass"
                import_info = JavaImportInfo(
                    import_path=long_path,
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_class_name_all_uppercase():
    """Test that all-uppercase class names are extracted correctly."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.example.XML",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_class_name_mixed_case():
    """Test that mixed-case class names are extracted correctly."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.example.MyXmlParser",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_non_existent_local_package():
    """Test resolving a non-existent local package returns is_external=True."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=Path("/fake/src")):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                import_info = JavaImportInfo(
                    import_path="com.example.NonExistent",
                    is_static=False,
                    is_wildcard=False,
                    start_line=1,
                    end_line=1
                )
                codeflash_output = resolver.resolve_imports([import_info]); result = codeflash_output

def test_resolve_imports_preserves_order():
    """Test that resolve_imports preserves the order of input imports."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                imports = [
                    JavaImportInfo(import_path="java.util.List", is_static=False, is_wildcard=False, start_line=1, end_line=1),
                    JavaImportInfo(import_path="org.junit.Test", is_static=False, is_wildcard=False, start_line=2, end_line=2),
                    JavaImportInfo(import_path="java.lang.String", is_static=False, is_wildcard=False, start_line=3, end_line=3),
                    JavaImportInfo(import_path="com.google.Guava", is_static=False, is_wildcard=False, start_line=4, end_line=4),
                ]
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output

def test_resolve_imports_large_batch_same_type():
    """Test resolving a large batch (500) of standard library imports."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                # Create 500 standard library imports
                imports = [
                    JavaImportInfo(
                        import_path=f"java.util.Collection{i}",
                        is_static=False,
                        is_wildcard=False,
                        start_line=i,
                        end_line=i
                    )
                    for i in range(500)
                ]
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output
                # Verify all are marked as external (standard library)
                for resolved in result:
                    pass

def test_resolve_imports_large_batch_mixed_types():
    """Test resolving a large batch (500) of mixed import types."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                imports = []
                # Add 200 standard library imports
                for i in range(200):
                    imports.append(JavaImportInfo(
                        import_path=f"java.util.Item{i}",
                        is_static=False,
                        is_wildcard=False,
                        start_line=i,
                        end_line=i
                    ))
                # Add 200 external library imports
                for i in range(200):
                    imports.append(JavaImportInfo(
                        import_path=f"org.springframework.beans.Item{i}",
                        is_static=False,
                        is_wildcard=False,
                        start_line=200 + i,
                        end_line=200 + i
                    ))
                # Add 100 non-existent local packages
                for i in range(100):
                    imports.append(JavaImportInfo(
                        import_path=f"com.example.app.Item{i}",
                        is_static=False,
                        is_wildcard=False,
                        start_line=400 + i,
                        end_line=400 + i
                    ))
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output
                # Verify first 200 are standard library
                for i in range(200):
                    pass
                # Verify next 200 are external
                for i in range(200, 400):
                    pass
                # Verify last 100 are also external (not found in project)
                for i in range(400, 500):
                    pass

def test_resolve_imports_large_batch_with_caching():
    """Test that caching improves performance for repeated imports."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                # Create imports with repetition
                imports = []
                repeated_path = "com.example.repeated.Class"
                for i in range(500):
                    if i % 5 == 0:
                        imports.append(JavaImportInfo(
                            import_path=repeated_path,
                            is_static=False,
                            is_wildcard=False,
                            start_line=i,
                            end_line=i
                        ))
                    else:
                        imports.append(JavaImportInfo(
                            import_path=f"com.example.unique{i}.Class",
                            is_static=False,
                            is_wildcard=False,
                            start_line=i,
                            end_line=i
                        ))
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output

def test_resolve_imports_large_batch_with_wildcards():
    """Test resolving a large batch (300) of wildcard imports."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                imports = [
                    JavaImportInfo(
                        import_path=f"java.util.package{i}",
                        is_static=False,
                        is_wildcard=True,
                        start_line=i,
                        end_line=i
                    )
                    for i in range(300)
                ]
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output
                # Verify all are marked as wildcard
                for resolved in result:
                    pass

def test_resolve_imports_large_batch_with_static_imports():
    """Test resolving a large batch (300) of static imports."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                imports = [
                    JavaImportInfo(
                        import_path=f"java.lang.Math.PI{i}",
                        is_static=True,
                        is_wildcard=False,
                        start_line=i,
                        end_line=i
                    )
                    for i in range(300)
                ]
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output

def test_resolve_imports_large_batch_all_common_external_packages():
    """Test resolving imports from all common external package prefixes."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                external_prefixes = [
                    "org.junit.Class",
                    "org.mockito.Class",
                    "org.assertj.Class",
                    "org.hamcrest.Class",
                    "org.slf4j.Class",
                    "org.apache.Class",
                    "org.springframework.Class",
                    "com.google.Class",
                    "com.fasterxml.Class",
                    "io.netty.Class",
                    "io.github.Class",
                    "lombok.Class",
                ]
                imports = []
                for prefix in external_prefixes:
                    for i in range(30):
                        imports.append(JavaImportInfo(
                            import_path=f"{prefix}.Item{i}",
                            is_static=False,
                            is_wildcard=False,
                            start_line=len(imports),
                            end_line=len(imports)
                        ))
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output
                # Verify all are marked as external
                for resolved in result:
                    pass

def test_resolve_imports_large_batch_all_standard_packages():
    """Test resolving imports from all standard Java library packages."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                standard_prefixes = [
                    "java.Class",
                    "javax.Class",
                    "sun.Class",
                    "com.sun.Class",
                    "jdk.Class",
                    "org.w3c.Class",
                    "org.xml.Class",
                    "org.ietf.Class",
                ]
                imports = []
                for prefix in standard_prefixes:
                    for i in range(50):
                        imports.append(JavaImportInfo(
                            import_path=f"{prefix}.Item{i}",
                            is_static=False,
                            is_wildcard=False,
                            start_line=len(imports),
                            end_line=len(imports)
                        ))
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output
                # Verify all are marked as external (standard library)
                for resolved in result:
                    pass

def test_resolve_imports_large_batch_with_very_long_paths():
    """Test resolving a large batch with very long import paths."""
    with patch('codeflash.languages.java.import_resolver.get_project_info', return_value=None):
        with patch('codeflash.languages.java.import_resolver.find_source_root', return_value=None):
            with patch('codeflash.languages.java.import_resolver.find_test_root', return_value=None):
                resolver = JavaImportResolver(Path("/fake/project"))
                imports = []
                for i in range(100):
                    # Create paths with 15 nested levels
                    long_path = ".".join([f"level{j}" for j in range(15)]) + f".Class{i}"
                    imports.append(JavaImportInfo(
                        import_path=long_path,
                        is_static=False,
                        is_wildcard=False,
                        start_line=i,
                        end_line=i
                    ))
                codeflash_output = resolver.resolve_imports(imports); result = codeflash_output
# 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-03T18.45.53 and push.

[KRRT7]

Closing stale bot PR.