⚡️ Speed up method JavaSupport.add_global_declarations by 16% 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.

---

📄 16% (0.16x) speedup for JavaSupport.add_global_declarations in codeflash/languages/java/support.py

⏱️ Runtime : 194 microseconds → 168 microseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves a 15% runtime improvement (194μs → 168μs) by eliminating an unnecessary tuple assignment operation that was discarding unused parameters.

Key Change:
Removed the line _ = optimized_code, module_abspath which existed solely to suppress unused parameter warnings but consumed 62.5% of the function's execution time (196ns out of 313ns total).

Why This Speeds Up the Code:
In Python, tuple packing operations (_ = a, b) have a non-trivial cost involving:

• Creating a tuple object in memory
• Packing two references into it
• Assigning it to a variable (even if that variable is immediately discarded)

Since add_global_declarations always returns original_source unchanged and never uses optimized_code or module_abspath, this tuple assignment was pure overhead. The line profiler data confirms this cost at 196ns per call (170.9ns per hit).

Impact Across Test Cases:
The optimization shows consistent improvements across all test scenarios:

• Simple calls: 21-50% faster (e.g., empty strings test: 37.1% faster)
• Repeated operations: 14.5% faster over 1000 calls
• Large code handling: 27.1% faster even with 100k character optimized_code
• Complex scenarios: 15.6% faster with 100 repeated calls on large source

The improvement is most pronounced in high-frequency invocation scenarios (1145 hits in the profiler), making this optimization particularly valuable if this function is called in hot paths during Java code processing workflows.

What Was Preserved:
All other aspects remain identical—imports, class structure, method signature, and the core behavior of returning original_source unchanged—ensuring zero risk to existing functionality.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from pathlib import Path

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.support import JavaSupport

def test_returns_original_unchanged_with_different_optimized_code():
    # Create a real JavaSupport instance using the real constructor.
    js = JavaSupport()
    # Provide an optimized_code that is different from the original_source.
    optimized = "public class Optimized { /* optimized content */ }"
    original = "public class Original { /* original content */ }"
    # module_abspath must be a Path instance (type hinted); choose a simple Path.
    module_path = Path("Example.java")
    # The contract of add_global_declarations (as implemented) is to return original_source.
    codeflash_output = js.add_global_declarations(optimized, original, module_path); result = codeflash_output # 400ns -> 301ns (32.9% faster)

def test_empty_strings_return_empty():
    # Ensure empty strings are handled and returned verbatim.
    js = JavaSupport()
    optimized = ""
    original = ""
    module_path = Path("empty.java")
    codeflash_output = js.add_global_declarations(optimized, original, module_path); result = codeflash_output # 440ns -> 321ns (37.1% faster)

def test_preserves_multiline_and_special_characters():
    js = JavaSupport()
    # Original contains newlines, tabs, special characters, and unicode.
    original = (
        "// Example class\n"
        "public class Example {\n"
        "    /* multi-line\n"
        "       comment */\n"
        "    String s = \"Spécial \\n \\t \\u2603\"; // snowman\n"
        "}\n"
    )
    # Optimized code contains different declarations (but should be ignored).
    optimized = "/* optimized version with different declarations */"
    module_path = Path("/path/to/Example.java")
    codeflash_output = js.add_global_declarations(optimized, original, module_path); result = codeflash_output # 441ns -> 340ns (29.7% faster)

def test_none_original_source_returns_none():
    # Although typing indicates original_source should be a str, the implementation
    # simply returns the original argument. Verify behavior with None.
    js = JavaSupport()
    optimized = "some optimized content"
    original = None  # intentionally using an edge value
    module_path = Path("NoneCase.java")
    codeflash_output = js.add_global_declarations(optimized, original, module_path); result = codeflash_output # 461ns -> 330ns (39.7% faster)

def test_various_module_paths_are_ignored_but_required_type():
    js = JavaSupport()
    optimized = "opt"
    original = "orig"
    # Try different Path variants to ensure module_abspath is not used.
    for p in (Path("."), Path("/absolute/path/to/module.java"), Path("relative/module.java")):
        codeflash_output = js.add_global_declarations(optimized + str(p), original, p); result = codeflash_output # 842ns -> 680ns (23.8% faster)

def test_many_calls_consistent_behavior():
    js = JavaSupport()
    module_path = Path("LargeScale.java")
    # Call the method 1000 times with slightly different optimized_code strings.
    for i in range(1000):
        optimized = f"// optimized version {i}\n" + ("x" * (i % 50))  # varying-size optimized code
        original = f"// original content #{i}\nint x = {i};\n"
        codeflash_output = js.add_global_declarations(optimized, original, module_path); result = codeflash_output # 160μs -> 140μs (14.5% faster)

def test_large_optimized_code_does_not_affect_return():
    js = JavaSupport()
    # Create a very large optimized_code (100k characters) to simulate heavy content.
    optimized = "/*" + ("optimized_content\n" * 5000) + "*/"
    original = "public class KeepMe { /* important original */ }\n"
    module_path = Path("HugeOptimized.java")
    codeflash_output = js.add_global_declarations(optimized, original, module_path); result = codeflash_output # 521ns -> 410ns (27.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from pathlib import Path

# imports
import pytest
from codeflash.languages.java.support import JavaSupport

class TestAddGlobalDeclarationsBasic:
    """Basic tests for add_global_declarations - verify fundamental functionality."""

    def test_returns_original_source_unchanged(self):
        """Test that the function returns the original_source parameter unchanged."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Test { public void method() {} }"
        path = Path("/test/module.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 460ns -> 320ns (43.8% faster)

    def test_ignores_optimized_code(self):
        """Test that changes in optimized_code do not affect the result."""
        support = JavaSupport()
        original = "public class Original { }"
        optimized1 = "public class Optimized1 { }"
        optimized2 = "public class Optimized2 { }"
        path = Path("/test/module.java")
        
        codeflash_output = support.add_global_declarations(optimized1, original, path); result1 = codeflash_output # 431ns -> 330ns (30.6% faster)
        codeflash_output = support.add_global_declarations(optimized2, original, path); result2 = codeflash_output # 230ns -> 190ns (21.1% faster)

    def test_ignores_module_path(self):
        """Test that different module paths produce the same result."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Optimized { }"
        path1 = Path("/test/module.java")
        path2 = Path("/other/path/module.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path1); result1 = codeflash_output # 421ns -> 320ns (31.6% faster)
        codeflash_output = support.add_global_declarations(optimized, original, path2); result2 = codeflash_output # 220ns -> 181ns (21.5% faster)

    def test_with_simple_class_definition(self):
        """Test with a simple Java class definition."""
        support = JavaSupport()
        original = "public class Main { public static void main(String[] args) { } }"
        optimized = "public class Main { public static void main(String[] args) { System.out.println(\"optimized\"); } }"
        path = Path("/src/Main.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 380ns -> 311ns (22.2% faster)

    def test_with_imports_and_class(self):
        """Test with source containing import statements and class definition."""
        support = JavaSupport()
        original = "import java.util.*;\npublic class Test { }"
        optimized = "import java.util.*;\nimport java.io.*;\npublic class Test { }"
        path = Path("/src/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 411ns -> 331ns (24.2% faster)

    def test_with_package_declaration(self):
        """Test with source containing package declaration."""
        support = JavaSupport()
        original = "package com.example;\npublic class MyClass { }"
        optimized = "package com.example;\npublic class MyClass { private int x = 5; }"
        path = Path("/src/com/example/MyClass.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 411ns -> 320ns (28.4% faster)

class TestAddGlobalDeclarationsEdgeCases:
    """Edge case tests - evaluate behavior with extreme or unusual conditions."""

    def test_with_empty_original_source(self):
        """Test with empty original source string."""
        support = JavaSupport()
        original = ""
        optimized = "public class Test { }"
        path = Path("/test/module.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 381ns -> 300ns (27.0% faster)

    def test_with_empty_optimized_code(self):
        """Test with empty optimized code string."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = ""
        path = Path("/test/module.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 420ns -> 311ns (35.0% faster)

    def test_with_both_empty(self):
        """Test when both original_source and optimized_code are empty."""
        support = JavaSupport()
        original = ""
        optimized = ""
        path = Path("/test/module.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 400ns -> 281ns (42.3% faster)

    def test_with_multiline_original_source(self):
        """Test with multiline original source containing various elements."""
        support = JavaSupport()
        original = """package com.example;

import java.util.List;
import java.util.ArrayList;

public class TestClass {
    private List<String> items;
    
    public TestClass() {
        this.items = new ArrayList<>();
    }
    
    public void addItem(String item) {
        items.add(item);
    }
}"""
        optimized = """package com.example;

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

public class TestClass {
    private List<String> items;
    
    public TestClass() {
        this.items = Collections.synchronizedList(new ArrayList<>());
    }
    
    public void addItem(String item) {
        items.add(item);
    }
}"""
        path = Path("/src/com/example/TestClass.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 421ns -> 280ns (50.4% faster)

    def test_with_unicode_characters(self):
        """Test with source containing unicode characters (comments, strings)."""
        support = JavaSupport()
        original = '// 日本語コメント\npublic class Test { String s = "hello"; }'
        optimized = '// 日本語コメント\npublic class Test { String s = "optimized"; }'
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 391ns -> 281ns (39.1% faster)

    def test_with_special_characters_in_strings(self):
        """Test with source containing special characters in string literals."""
        support = JavaSupport()
        original = r'public class Test { String s = "line1\nline2\ttab"; }'
        optimized = r'public class Test { String s = "different\nstring"; }'
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 411ns -> 300ns (37.0% faster)

    def test_with_very_long_original_source(self):
        """Test with a very long original source string."""
        support = JavaSupport()
        # Create a long original source with many methods
        original = "public class Test {\n"
        for i in range(100):
            original += f"    public void method{i}() {{ System.out.println({i}); }}\n"
        original += "}"
        
        optimized = original.replace("method", "optimized_method")
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 410ns -> 261ns (57.1% faster)

    def test_with_relative_path(self):
        """Test with relative path instead of absolute."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Test { }"
        path = Path("src/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 401ns -> 330ns (21.5% faster)

    def test_with_windows_style_path(self):
        """Test with Windows-style path."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Test { }"
        path = Path("C:\\Users\\test\\src\\Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 391ns -> 320ns (22.2% faster)

    def test_with_deeply_nested_path(self):
        """Test with deeply nested file path."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Test { }"
        path = Path("/very/deep/nested/path/to/some/module/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 430ns -> 310ns (38.7% faster)

    def test_with_large_code_difference(self):
        """Test when optimized and original differ significantly."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = """
public class Test {
    private static final int SIZE = 1000;
    private int[] data = new int[SIZE];
    
    public void process() {
        for (int i = 0; i < data.length; i++) {
            data[i] = i * 2;
        }
    }
    
    public int calculate() {
        int sum = 0;
        for (int val : data) {
            sum += val;
        }
        return sum;
    }
}
"""
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 391ns -> 300ns (30.3% faster)

    def test_with_annotations(self):
        """Test with source containing Java annotations."""
        support = JavaSupport()
        original = """@Override
public class Test {
    @Deprecated
    public void oldMethod() { }
}"""
        optimized = """@Override
public class Test {
    @Deprecated
    @SuppressWarnings("all")
    public void oldMethod() { }
}"""
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 390ns -> 280ns (39.3% faster)

    def test_with_generic_types(self):
        """Test with source containing complex generic type declarations."""
        support = JavaSupport()
        original = "public class Test { Map<String, List<Integer>> data; }"
        optimized = "public class Test { Map<String, List<Integer>> data; }"
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 390ns -> 310ns (25.8% faster)

class TestAddGlobalDeclarationsReturnType:
    """Tests to verify return type and string identity characteristics."""

    def test_return_type_is_string(self):
        """Test that return value is a string."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Optimized { }"
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 391ns -> 311ns (25.7% faster)

    def test_return_value_is_original_parameter(self):
        """Test that the returned value is the original_source parameter."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Optimized { }"
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 380ns -> 290ns (31.0% faster)

    def test_multiple_calls_with_same_inputs_produce_same_output(self):
        """Test that multiple calls with identical inputs produce identical outputs."""
        support = JavaSupport()
        original = "public class Test { }"
        optimized = "public class Optimized { }"
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result1 = codeflash_output # 411ns -> 291ns (41.2% faster)
        codeflash_output = support.add_global_declarations(optimized, original, path); result2 = codeflash_output # 231ns -> 190ns (21.6% faster)
        codeflash_output = support.add_global_declarations(optimized, original, path); result3 = codeflash_output # 170ns -> 140ns (21.4% faster)

class TestAddGlobalDeclarationsMultipleInstances:
    """Test behavior across multiple JavaSupport instances."""

    def test_multiple_instances_produce_same_result(self):
        """Test that different JavaSupport instances produce the same result."""
        support1 = JavaSupport()
        support2 = JavaSupport()
        
        original = "public class Test { }"
        optimized = "public class Optimized { }"
        path = Path("/test/Test.java")
        
        codeflash_output = support1.add_global_declarations(optimized, original, path); result1 = codeflash_output # 390ns -> 311ns (25.4% faster)
        codeflash_output = support2.add_global_declarations(optimized, original, path); result2 = codeflash_output # 221ns -> 180ns (22.8% faster)

    def test_sequential_calls_on_same_instance(self):
        """Test multiple sequential calls on the same instance."""
        support = JavaSupport()
        
        # First call
        original1 = "public class Test1 { }"
        optimized1 = "public class Optimized1 { }"
        path1 = Path("/test/Test1.java")
        codeflash_output = support.add_global_declarations(optimized1, original1, path1); result1 = codeflash_output # 411ns -> 311ns (32.2% faster)
        
        # Second call
        original2 = "public class Test2 { }"
        optimized2 = "public class Optimized2 { }"
        path2 = Path("/test/Test2.java")
        codeflash_output = support.add_global_declarations(optimized2, original2, path2); result2 = codeflash_output # 230ns -> 180ns (27.8% faster)

class TestAddGlobalDeclarationsLargeScale:
    """Large-scale tests for performance and scalability."""

    def test_with_large_original_source_100_methods(self):
        """Test with a large original source containing 100 methods."""
        support = JavaSupport()
        
        # Generate a large class with many methods
        original = "public class LargeClass {\n"
        for i in range(100):
            original += f"    public int method{i}(int x) {{\n"
            original += f"        return x + {i};\n"
            original += f"    }}\n"
        original += "}\n"
        
        optimized = original.replace("return x +", "return x *")
        path = Path("/test/LargeClass.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 401ns -> 321ns (24.9% faster)

    def test_with_very_long_single_method(self):
        """Test with a very long single method containing many statements."""
        support = JavaSupport()
        
        original = "public class Test {\n    public void longMethod() {\n"
        for i in range(500):
            original += f"        int x{i} = {i};\n"
        original += "    }\n}\n"
        
        optimized = original.replace("int x", "long y")
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 391ns -> 331ns (18.1% faster)

    def test_with_deeply_nested_generics(self):
        """Test with complex deeply nested generic type declarations."""
        support = JavaSupport()
        
        original = "public class Test {\n"
        original += "    Map<String, Map<Integer, List<Set<String>>>> complex;\n"
        original += "    Map<String, Map<String, Map<String, Map<String, String>>>> veryComplex;\n"
        original += "}\n"
        
        optimized = original + "// optimized"
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 340ns -> 340ns (0.000% faster)

    def test_with_large_number_of_imports(self):
        """Test with a large number of import statements."""
        support = JavaSupport()
        
        original = ""
        for i in range(200):
            original += f"import package.subpackage.module{i}.Class{i};\n"
        original += "public class Test { }\n"
        
        optimized = original.replace("module", "optimized_module")
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 381ns -> 310ns (22.9% faster)

    def test_with_large_multiline_comments(self):
        """Test with large multiline Javadoc comments."""
        support = JavaSupport()
        
        original = "/**\n"
        for i in range(100):
            original += f" * Line {i} of documentation\n"
        original += " */\npublic class Test { }\n"
        
        optimized = original.replace("documentation", "docs")
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 411ns -> 310ns (32.6% faster)

    def test_with_large_string_literals(self):
        """Test with large string literals in the source."""
        support = JavaSupport()
        
        large_string = "x" * 10000
        original = f'public class Test {{ String s = "{large_string}"; }}\n'
        
        optimized = f'public class Test {{ String s = "{large_string}_optimized"; }}\n'
        path = Path("/test/Test.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 401ns -> 331ns (21.1% faster)

    def test_with_1000_line_source_file(self):
        """Test with a source file equivalent to ~1000 lines of code."""
        support = JavaSupport()
        
        original = "public class LargeFile {\n"
        for i in range(200):
            original += f"    public class InnerClass{i} {{\n"
            for j in range(4):
                original += f"        public void method{j}() {{\n"
                original += f"            System.out.println({i});\n"
                original += f"        }}\n"
            original += f"    }}\n"
        original += "}\n"
        
        optimized = original.replace("println", "err.println")
        path = Path("/test/LargeFile.java")
        
        codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 381ns -> 351ns (8.55% faster)

    def test_performance_with_repeated_calls_on_large_source(self):
        """Test performance with repeated calls on large source."""
        support = JavaSupport()
        
        # Create a moderately large source
        original = "public class PerfTest {\n"
        for i in range(50):
            original += f"    public void method{i}() {{\n"
            for j in range(10):
                original += f"        int x{j} = {j};\n"
            original += f"    }}\n"
        original += "}\n"
        
        optimized = original.replace("int x", "long y")
        path = Path("/test/PerfTest.java")
        
        # Perform 100 calls and verify all return original
        for _ in range(100):
            codeflash_output = support.add_global_declarations(optimized, original, path); result = codeflash_output # 16.5μs -> 14.3μs (15.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1199-2026-02-21T00.51.45 and push.

[claude]

PR Review Summary

Prek Checks

• ruff check: Found 3 unused-import warnings in codeflash/languages/registry.py (F401). These are false positives — the imports are side-effect imports used to register language support modules. Auto-fix was reverted as it would break the registration mechanism. No action needed.
• ruff format: Passed
• mypy: 5 pre-existing errors in codeflash/languages/java/support.py (not introduced by this PR — present on base branch omni-java)

Code Review

No issues found. This is a trivial optimization that removes one unused tuple assignment:

_ = optimized_code, module_abspath

The add_global_declarations method simply returns original_source unchanged. The removed line existed only to suppress unused-parameter warnings but introduced unnecessary tuple packing overhead. The change is safe — the parameters remain in the method signature as required by the LanguageSupport base class interface.

Note: One pre-existing test failure detected in test_comparator.py::TestTestResultsTableSchema::test_comparator_reads_test_results_table_identical — unrelated to this PR.

Test Coverage

File	Base (omni-java)	PR	Change
codeflash/languages/java/support.py	47% (179 stmts, 95 miss)	47% (178 stmts, 94 miss)	No change

• The removed line was 1 statement. Coverage percentage is unchanged.
• No new code was added, so no new coverage requirements apply.
• No coverage regression.

---

Last updated: 2026-02-21