fix: scope field extraction to target class to prevent cross-class injection

find_fields() was called without a class_name filter, causing fields from
inner/anonymous classes to be injected into the outer target class. Now
scoped to target_method.class_name using the existing filter parameter.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mohamedashrraf222

codeflash/languages/java/replacement.py

@@ -69,7 +69,6 @@ def _parse_optimization_source(new_source: str, target_method_name: str, analyze
     if classes:
         # It's a class - extract components
         methods = analyzer.find_methods(new_source)
-        fields = analyzer.find_fields(new_source)
 
         # Find the target method and its index among all methods
         target_method = None
@@ -128,7 +127,11 @@ def _parse_optimization_source(new_source: str, target_method_name: str, analyze
                 ctor_end = c.end_line
                 modified_constructors.append("".join(ctor_lines[ctor_start:ctor_end]))
 
-        # Extract fields
+        # Extract fields scoped to the target method's class only.
+        # Without class filtering, fields from inner/anonymous classes would be
+        # incorrectly injected into the outer target class.
+        target_class_name = target_method.class_name if target_method else None
+        fields = analyzer.find_fields(new_source, class_name=target_class_name)
         for f in fields:
             if f.source_text:
                 new_fields.append(f.source_text)

tests/test_languages/test_java/test_replacement.py

@@ -1929,3 +1929,77 @@ def test_anonymous_iterator_methods_not_hoisted_to_class(self, tmp_path, java_su
 }
 """
         assert new_code == expected_code
+
+
+class TestFieldInjectionClassFiltering:
+    """Tests that fields from inner/anonymous classes are not injected into the target class."""
+
+    def test_inner_class_fields_not_injected_into_outer(self, tmp_path, java_support):
+        """Reproduces the Guava/Iterables.mergeSorted bug.
+
+        When the LLM generates an optimization that includes an inner class with
+        fields (e.g., generic type parameters), those fields must NOT be injected
+        into the outer class where the target method lives.
+        """
+        from codeflash.discovery.functions_to_optimize import FunctionParent, FunctionToOptimize
+
+        java_file = tmp_path / "Outer.java"
+        original_code = """\
+public class Outer {
+    private int count;
+
+    public int process(int x) {
+        return x + count;
+    }
+}
+"""
+        java_file.write_text(original_code, encoding="utf-8")
+
+        # LLM generates optimization with an inner class that has its own field.
+        # The inner class's field should NOT be injected into Outer.
+        optimized_markdown = f"""```java:{java_file.relative_to(tmp_path)}
+public class Outer {{
+    private int count;
+    private static final int OFFSET = 10;
+
+    public int process(int x) {{
+        return x + count + OFFSET;
+    }}
+
+    private static class Inner {{
+        private final String badField;
+
+        Inner(String s) {{
+            this.badField = s;
+        }}
+    }}
+}}
+```"""
+
+        optimized_code = CodeStringsMarkdown.parse_markdown_code(optimized_markdown, expected_language="java")
+
+        function_to_optimize = FunctionToOptimize(
+            function_name="process",
+            file_path=java_file,
+            starting_line=4,
+            ending_line=6,
+            parents=[FunctionParent(name="Outer", type="ClassDef")],
+            qualified_name="Outer.process",
+            is_method=True,
+        )
+
+        result = java_support.replace_function_definitions(
+            function_names=["process"],
+            optimized_code=optimized_code,
+            module_abspath=java_file,
+            project_root_path=tmp_path,
+            function_to_optimize=function_to_optimize,
+        )
+
+        assert result is True
+        new_code = java_file.read_text(encoding="utf-8")
+
+        # Only OFFSET field should be added (belongs to Outer).
+        # badField belongs to Inner and should NOT appear.
+        assert "OFFSET" in new_code
+        assert "badField" not in new_code