⚡️ Speed up function is_java by 58% 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.

---

📄 58% (0.58x) speedup for is_java in codeflash/languages/current.py

⏱️ Runtime : 798 microseconds → 506 microseconds (best of 203 runs)

📝 Explanation and details

This optimization achieves a 57% runtime improvement (from 798μs to 506μs) by eliminating redundant attribute lookups through module-level caching of Language.JAVA.

What Changed:
A new module-level constant _JAVA = Language.JAVA was introduced, and the comparison in is_java() was changed from _current_language == Language.JAVA to _current_language == _JAVA.

Why This Is Faster:
In Python, accessing an enum member like Language.JAVA involves an attribute lookup on the Language class object every time it's executed. The line profiler shows this function being called 3,299 times with a per-hit cost of ~390ns in the original version. By caching the enum member reference at module load time, each function call now performs a simple variable lookup from the local module namespace instead of traversing the class attribute hierarchy. This reduces the per-hit cost to ~284ns (27% reduction per call).

Test Performance:
The annotated tests demonstrate consistent speedups across all scenarios:

• Basic equality checks: 31-70% faster (e.g., Java check: 592ns → 451ns, None check: 792ns → 471ns)
• Consecutive calls show even better improvements due to CPU caching benefits
• Parametrized tests across all languages: 61% faster
• Large-scale repeated operations remain efficient with the simpler lookup

Impact on Workloads:
Given that is_java() appears in benchmark replay tests and likely serves as a frequent language guard check throughout the codebase, this optimization is particularly valuable for:

• Hot paths with repeated language checks (common in multi-language codebases)
• Conditional compilation or feature-gating based on language selection
• Performance-critical sections where this check occurs in tight loops

The optimization maintains identical semantics while reducing overhead from repeated enum member access, making it a pure performance win with no behavioral changes.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
# Import the module that contains the is_java function and the Language enum.
from codeflash.languages import current as current_mod
from codeflash.languages.base import Language
from codeflash.languages.current import is_java

# function to test
# The tests below exercise current_mod.is_java() (the exact original function)
# by manipulating the module-level _current_language variable and observing results.
# We never redefine or patch is_java; we call the real implementation as required.

def _restore_original_language(original):
    """Helper to restore the module-level _current_language after a test."""
    current_mod._current_language = original

def test_is_java_true_when_language_set_to_enum_member():
    # Save original state to avoid side effects across tests.
    original = getattr(current_mod, "_current_language", None)
    try:
        # Set the internal current language to the exact enum member for Java.
        current_mod._current_language = Language.JAVA
        # The function should return True when the current language is the Java enum.
        codeflash_output = current_mod.is_java()
    finally:
        # Restore original state no matter what happens.
        _restore_original_language(original)

@pytest.mark.parametrize(
    "other_lang",
    [
        Language.PYTHON,  # a different enum member
        Language.JAVASCRIPT,  # another different enum member
        Language.TYPESCRIPT,  # yet another
    ],
)
def test_is_java_false_for_other_enum_members(other_lang):
    # Verify that non-Java enum values return False.
    original = getattr(current_mod, "_current_language", None)
    try:
        current_mod._current_language = other_lang
        codeflash_output = current_mod.is_java()
    finally:
        _restore_original_language(original)

def test_is_java_true_for_string_value_equal_to_java():
    # Edge case: since Language is defined as `str, Enum`, plain 'java' strings
    # may compare equal to Language.JAVA. Ensure the function follows equality semantics.
    original = getattr(current_mod, "_current_language", None)
    try:
        # Assign the ascii string "java" (not the enum). __eq__ comparison should still succeed.
        current_mod._current_language = "java"
        # Because equality is used (_current_language == Language.JAVA),
        # a plain 'java' string will compare equal to the Language.JAVA member.
        codeflash_output = current_mod.is_java()
    finally:
        _restore_original_language(original)

@pytest.mark.parametrize(
    "weird_value",
    [
        None,  # explicit absence of a language
        0,  # integer
        1.23,  # float
        True,  # boolean
        [],  # list
        {},  # dict
        object(),  # arbitrary object
    ],
)
def test_is_java_false_for_unexpected_types(weird_value):
    # The function should be robust and return False for unexpected types,
    # not raise exceptions. We set a variety of builtin types to confirm behavior.
    original = getattr(current_mod, "_current_language", None)
    try:
        current_mod._current_language = weird_value
        # Ensure calling is_java() does not raise and returns a boolean False.
        codeflash_output = current_mod.is_java()
    finally:
        _restore_original_language(original)

def test_is_java_does_not_modify_state():
    # Ensure that calling is_java() is a read-only check and does not mutate module state.
    original = getattr(current_mod, "_current_language", None)
    try:
        # Try with Java set, call is_java(), and ensure _current_language stays the same.
        current_mod._current_language = Language.JAVA
        before = current_mod._current_language
        codeflash_output = current_mod.is_java(); result = codeflash_output
        after = current_mod._current_language
    finally:
        _restore_original_language(original)

def test_large_scale_repeated_non_java_checks():
    # Large-scale scenario: repeatedly set many non-Java values and call is_java().
    # We limit repetitions to 500 iterations to respect the "avoid >1000" guideline.
    original = getattr(current_mod, "_current_language", None)
    try:
        non_java_values = [Language.PYTHON, Language.JAVASCRIPT, Language.TYPESCRIPT]
        # Repeat the sequence to create a larger workload (500 steps).
        # This checks for performance regressions and state handling across many calls.
        for i in range(500):
            # Cycle through the non-java values.
            val = non_java_values[i % len(non_java_values)]
            current_mod._current_language = val
            # Each call must consistently return False for non-Java values.
            codeflash_output = current_mod.is_java()
    finally:
        _restore_original_language(original)

def test_large_scale_alternating_java_and_nonjava():
    # Another large-scale test that alternates between Java and non-Java values.
    # This ensures correctness across state flips and many invocations.
    original = getattr(current_mod, "_current_language", None)
    try:
        # We'll perform 500 alternations (again under the 1000 iteration limit).
        for i in range(500):
            if i % 2 == 0:
                current_mod._current_language = Language.JAVA
                codeflash_output = current_mod.is_java()
            else:
                current_mod._current_language = Language.PYTHON
                codeflash_output = current_mod.is_java()
    finally:
        _restore_original_language(original)

def test_setting_equivalent_str_and_enum_interaction():
    # Confirm that setting enum then comparing from the opposite side still yields correct result.
    original = getattr(current_mod, "_current_language", None)
    try:
        # Set to Language.JAVA and assert equality when comparing the other way around.
        current_mod._current_language = Language.JAVA
        # The is_java function uses _current_language == Language.JAVA,
        # so if a plain 'java' compares equal to the enum, the function must also detect that.
        current_mod._current_language = "java"
        codeflash_output = current_mod.is_java()
    finally:
        _restore_original_language(original)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from unittest.mock import patch

import pytest
from codeflash.languages.base import Language
from codeflash.languages.current import is_java

class TestIsJavaBasic:
    """Basic test cases for is_java function."""

    def test_is_java_returns_true_when_current_language_is_java(self):
        """Test that is_java returns True when _current_language is set to Java."""
        with patch('codeflash.languages.current._current_language', Language.JAVA):
            codeflash_output = is_java() # 592ns -> 451ns (31.3% faster)

    def test_is_java_returns_false_when_current_language_is_python(self):
        """Test that is_java returns False when _current_language is set to Python."""
        with patch('codeflash.languages.current._current_language', Language.PYTHON):
            codeflash_output = is_java() # 651ns -> 401ns (62.3% faster)

    def test_is_java_returns_false_when_current_language_is_javascript(self):
        """Test that is_java returns False when _current_language is set to JavaScript."""
        with patch('codeflash.languages.current._current_language', Language.JAVASCRIPT):
            codeflash_output = is_java() # 591ns -> 390ns (51.5% faster)

    def test_is_java_returns_false_when_current_language_is_typescript(self):
        """Test that is_java returns False when _current_language is set to TypeScript."""
        with patch('codeflash.languages.current._current_language', Language.TYPESCRIPT):
            codeflash_output = is_java() # 561ns -> 401ns (39.9% faster)

    def test_is_java_returns_boolean_type(self):
        """Test that is_java always returns a boolean type."""
        with patch('codeflash.languages.current._current_language', Language.JAVA):
            codeflash_output = is_java(); result = codeflash_output # 601ns -> 401ns (49.9% faster)

class TestIsJavaEdgeCases:
    """Edge case test cases for is_java function."""

    def test_is_java_returns_false_when_current_language_is_none(self):
        """Test that is_java returns False when _current_language is None."""
        with patch('codeflash.languages.current._current_language', None):
            codeflash_output = is_java() # 792ns -> 471ns (68.2% faster)

    def test_is_java_with_java_enum_value_directly(self):
        """Test is_java with Java enum value accessed directly."""
        java_value = Language.JAVA
        with patch('codeflash.languages.current._current_language', java_value):
            codeflash_output = is_java() # 601ns -> 421ns (42.8% faster)

    def test_is_java_with_python_enum_value_directly(self):
        """Test is_java with Python enum value accessed directly."""
        python_value = Language.PYTHON
        with patch('codeflash.languages.current._current_language', python_value):
            codeflash_output = is_java() # 611ns -> 390ns (56.7% faster)

    def test_is_java_language_comparison_is_exact_match(self):
        """Test that is_java performs exact equality comparison with Language.JAVA."""
        # This tests that the comparison is strict equality, not substring or partial matching
        with patch('codeflash.languages.current._current_language', Language.JAVA):
            codeflash_output = is_java() # 571ns -> 370ns (54.3% faster)
        
        # Verify that a different enum instance with the same string value would fail
        # (though in practice, Enum instances are singletons)
        with patch('codeflash.languages.current._current_language', Language.JAVASCRIPT):
            codeflash_output = is_java() # 421ns -> 290ns (45.2% faster)

    def test_is_java_with_unset_module_global(self):
        """Test is_java behavior when _current_language module global is not explicitly set."""
        # This tests the initial state where _current_language is None by default
        with patch('codeflash.languages.current._current_language', None):
            codeflash_output = is_java(); result = codeflash_output # 782ns -> 460ns (70.0% faster)

    def test_is_java_multiple_consecutive_calls_with_same_state(self):
        """Test that multiple consecutive calls with same language state return consistent results."""
        with patch('codeflash.languages.current._current_language', Language.JAVA):
            codeflash_output = is_java(); result1 = codeflash_output # 561ns -> 401ns (39.9% faster)
            codeflash_output = is_java(); result2 = codeflash_output # 300ns -> 211ns (42.2% faster)
            codeflash_output = is_java(); result3 = codeflash_output

    def test_is_java_multiple_consecutive_calls_with_none_state(self):
        """Test that multiple consecutive calls with None state return consistent results."""
        with patch('codeflash.languages.current._current_language', None):
            codeflash_output = is_java(); result1 = codeflash_output # 751ns -> 461ns (62.9% faster)
            codeflash_output = is_java(); result2 = codeflash_output # 340ns -> 241ns (41.1% faster)
            codeflash_output = is_java(); result3 = codeflash_output

class TestIsJavaAllLanguages:
    """Comprehensive test cases for is_java with all supported languages."""

    @pytest.mark.parametrize("language", [
        Language.PYTHON,
        Language.JAVASCRIPT,
        Language.TYPESCRIPT,
    ])
    def test_is_java_returns_false_for_non_java_languages(self, language):
        """Test that is_java returns False for all non-Java languages."""
        with patch('codeflash.languages.current._current_language', language):
            codeflash_output = is_java() # 2.01μs -> 1.25μs (61.0% faster)

    @pytest.mark.parametrize("language", [
        Language.JAVA,
    ])
    def test_is_java_returns_true_for_java_language(self, language):
        """Test that is_java returns True only for Java language."""
        with patch('codeflash.languages.current._current_language', language):
            codeflash_output = is_java() # 651ns -> 421ns (54.6% faster)

    def test_is_java_with_all_language_enum_values(self):
        """Test is_java against all possible Language enum values."""
        expected_results = {
            Language.JAVA: True,
            Language.PYTHON: False,
            Language.JAVASCRIPT: False,
            Language.TYPESCRIPT: False,
        }
        
        for language, expected in expected_results.items():
            with patch('codeflash.languages.current._current_language', language):
                codeflash_output = is_java(); result = codeflash_output

class TestIsJavaLargeScale:
    """Large scale test cases for is_java function performance."""

    def test_is_java_repeated_calls_performance(self):
        """Test that is_java handles many repeated calls efficiently."""
        # Execute function 1000 times with Java language set
        with patch('codeflash.languages.current._current_language', Language.JAVA):
            for _ in range(1000):
                codeflash_output = is_java(); result = codeflash_output

    def test_is_java_repeated_calls_with_none_performance(self):
        """Test that is_java handles many repeated calls with None state efficiently."""
        # Execute function 1000 times with None state
        with patch('codeflash.languages.current._current_language', None):
            for _ in range(1000):
                codeflash_output = is_java(); result = codeflash_output

    def test_is_java_alternating_language_states(self):
        """Test is_java with alternating language states across many iterations."""
        languages = [Language.JAVA, Language.PYTHON, Language.JAVASCRIPT, Language.TYPESCRIPT]
        expected = [True, False, False, False]
        
        for i in range(250):  # 250 iterations through all 4 languages = 1000 total calls
            language = languages[i % 4]
            expected_result = expected[i % 4]
            with patch('codeflash.languages.current._current_language', language):
                codeflash_output = is_java(); result = codeflash_output

    def test_is_java_boolean_return_value_consistency(self):
        """Test that is_java always returns a proper boolean (True or False, not truthy/falsy)."""
        test_states = [Language.JAVA, Language.PYTHON, None, Language.TYPESCRIPT]
        
        for state in test_states:
            with patch('codeflash.languages.current._current_language', state):
                codeflash_output = is_java(); result = codeflash_output

    def test_is_java_state_isolation_between_calls(self):
        """Test that state changes between calls are properly reflected in results."""
        states_sequence = [
            Language.JAVA,
            Language.PYTHON,
            Language.JAVA,
            Language.JAVASCRIPT,
            Language.JAVA,
        ]
        expected_results = [True, False, True, False, True]
        
        for state, expected in zip(states_sequence, expected_results):
            with patch('codeflash.languages.current._current_language', state):
                codeflash_output = is_java(); 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.

from codeflash.languages.current import is_java

def test_is_java():
    is_java()

🔎 Click to see Concolic Coverage Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_34v0t72u/tmp8loot7uh/test_concolic_coverage.py::test_is_java	821ns	481ns	70.7%✅

To edit these changes git checkout codeflash/optimize-pr1199-2026-02-01T22.54.08 and push.