feat: support void method optimization in Java pipeline

Discover void methods, instrument them by serializing the receiver instead
of a return value, and treat all-null comparisons as equivalent.

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

Author: HeshamHM28

codeflash/discovery/functions_to_optimize.py

@@ -195,7 +195,8 @@ def _find_all_functions_via_language_support(file_path: Path) -> dict[Path, list
 
     try:
         lang_support = get_language_support(file_path)
-        criteria = FunctionFilterCriteria(require_return=True)
+        require_return = lang_support.language != Language.JAVA
+        criteria = FunctionFilterCriteria(require_return=require_return)
         functions[file_path] = lang_support.discover_functions(file_path, criteria)
     except Exception as e:
         logger.debug(f"Failed to discover functions in {file_path}: {e}")
@@ -454,7 +455,8 @@ def find_all_functions_in_file(file_path: Path) -> dict[Path, list[FunctionToOpt
         from codeflash.languages.base import FunctionFilterCriteria
 
         lang_support = get_language_support(file_path)
-        criteria = FunctionFilterCriteria(require_return=True)
+        require_return = lang_support.language != Language.JAVA
+        criteria = FunctionFilterCriteria(require_return=require_return)
         source = file_path.read_text(encoding="utf-8")
         return {file_path: lang_support.discover_functions(source, file_path, criteria)}
     except Exception as e:

codeflash/languages/java/comparator.py

@@ -299,6 +299,16 @@ def compare_test_results(
         skipped_deser_errors = comparison.get("skippedDeserializationErrors", 0)
 
         if actual_comparisons == 0:
+            if skipped_placeholders > 0 and skipped_deser_errors == 0 and not comparison.get("diffs"):
+                # For void methods, all return values are null → all are "placeholder" skips.
+                # If no diffs and no deser errors, treat as equivalent (pass/fail verification).
+                logger.info(
+                    "Java comparison: void method — all return values null, treating as equivalent "
+                    "(total=%s, skipped_placeholders=%s)",
+                    comparison.get("totalInvocations", 0),
+                    skipped_placeholders,
+                )
+                return True, []
             logger.warning(
                 "Java comparison: no actual comparisons performed "
                 "(total=%s, skipped_placeholders=%s, skipped_deser_errors=%s). "

codeflash/languages/java/instrumentation.py

@@ -337,54 +337,94 @@ def wrap_target_calls_with_treesitter(
         orig_line = body_lines[line_idx]
         line_indent_str = " " * (len(orig_line) - len(orig_line.lstrip()))
 
+        is_void = target_return_type == "void"
         var_name = f"_cf_result{iter_id}_{call_counter}"
+        receiver = call.get("receiver", "this")
         cast_type = _infer_array_cast_type(orig_line)
-        if not cast_type and target_return_type and target_return_type != "void":
+        if not cast_type and target_return_type and not is_void:
             cast_type = target_return_type
         var_with_cast = f"({cast_type}){var_name}" if cast_type else var_name
 
-        capture_stmt_with_decl = f"var {var_name} = {call['full_call']};"
-        capture_stmt_assign = f"{var_name} = {call['full_call']};"
-        if precise_call_timing:
-            serialize_stmt = f"_cf_serializedResult{iter_id}_{call_counter} = com.codeflash.Serializer.serialize((Object) {var_name});"
-            start_stmt = f"_cf_start{iter_id}_{call_counter} = System.nanoTime();"
-            end_stmt = f"_cf_end{iter_id}_{call_counter} = System.nanoTime();"
+        if is_void:
+            bare_call_stmt = f"{call['full_call']};"
+            if precise_call_timing:
+                serialize_stmt = f"_cf_serializedResult{iter_id}_{call_counter} = com.codeflash.Serializer.serialize((Object) {receiver});"
+                start_stmt = f"_cf_start{iter_id}_{call_counter} = System.nanoTime();"
+                end_stmt = f"_cf_end{iter_id}_{call_counter} = System.nanoTime();"
+            else:
+                serialize_stmt = (
+                    f"_cf_serializedResult{iter_id} = com.codeflash.Serializer.serialize((Object) {receiver});"
+                )
+                start_stmt = f"_cf_start{iter_id} = System.nanoTime();"
+                end_stmt = f"_cf_end{iter_id} = System.nanoTime();"
         else:
-            serialize_stmt = f"_cf_serializedResult{iter_id} = com.codeflash.Serializer.serialize((Object) {var_name});"
-            start_stmt = f"_cf_start{iter_id} = System.nanoTime();"
-            end_stmt = f"_cf_end{iter_id} = System.nanoTime();"
+            capture_stmt_with_decl = f"var {var_name} = {call['full_call']};"
+            capture_stmt_assign = f"{var_name} = {call['full_call']};"
+            if precise_call_timing:
+                serialize_stmt = f"_cf_serializedResult{iter_id}_{call_counter} = com.codeflash.Serializer.serialize((Object) {var_name});"
+                start_stmt = f"_cf_start{iter_id}_{call_counter} = System.nanoTime();"
+                end_stmt = f"_cf_end{iter_id}_{call_counter} = System.nanoTime();"
+            else:
+                serialize_stmt = (
+                    f"_cf_serializedResult{iter_id} = com.codeflash.Serializer.serialize((Object) {var_name});"
+                )
+                start_stmt = f"_cf_start{iter_id} = System.nanoTime();"
+                end_stmt = f"_cf_end{iter_id} = System.nanoTime();"
 
         if call["parent_type"] == "expression_statement":
             es_start = call["_es_start_char"]
             es_end = call["_es_end_char"]
             if precise_call_timing:
                 # No indent on first line — body_text[:es_start] already has leading whitespace.
                 # Subsequent lines get line_indent_str.
-                var_decls = [
-                    f"Object {var_name} = null;",
-                    f"long _cf_end{iter_id}_{call_counter} = -1;",
-                    f"long _cf_start{iter_id}_{call_counter} = 0;",
-                    f"byte[] _cf_serializedResult{iter_id}_{call_counter} = null;",
-                ]
+                if is_void:
+                    var_decls = [
+                        f"long _cf_end{iter_id}_{call_counter} = -1;",
+                        f"long _cf_start{iter_id}_{call_counter} = 0;",
+                        f"byte[] _cf_serializedResult{iter_id}_{call_counter} = null;",
+                    ]
+                else:
+                    var_decls = [
+                        f"Object {var_name} = null;",
+                        f"long _cf_end{iter_id}_{call_counter} = -1;",
+                        f"long _cf_start{iter_id}_{call_counter} = 0;",
+                        f"byte[] _cf_serializedResult{iter_id}_{call_counter} = null;",
+                    ]
                 start_marker = f'System.out.println("!$######" + _cf_mod{iter_id} + ":" + _cf_cls{iter_id} + "." + _cf_test{iter_id} + ":" + _cf_fn{iter_id} + ":" + _cf_loop{iter_id} + ":{inv_id}" + "######$!");'
-                try_block = [
-                    "try {",
-                    f"    {start_stmt}",
-                    f"    {capture_stmt_assign}",
-                    f"    {end_stmt}",
-                    f"    {serialize_stmt}",
-                ]
+                if is_void:
+                    try_block = [
+                        "try {",
+                        f"    {start_stmt}",
+                        f"    {bare_call_stmt}",
+                        f"    {end_stmt}",
+                        f"    {serialize_stmt}",
+                    ]
+                else:
+                    try_block = [
+                        "try {",
+                        f"    {start_stmt}",
+                        f"    {capture_stmt_assign}",
+                        f"    {end_stmt}",
+                        f"    {serialize_stmt}",
+                    ]
                 finally_block = _generate_sqlite_write_code(
                     iter_id, call_counter, "", class_name, func_name, test_method_name, invocation_id=inv_id
                 )
                 all_lines = [*var_decls, start_marker, *try_block, *finally_block]
                 replacement = (
                     all_lines[0] + "\n" + "\n".join(f"{line_indent_str}{repl_line}" for repl_line in all_lines[1:])
                 )
+            elif is_void:
+                replacement = f"{bare_call_stmt} {serialize_stmt}"
             else:
                 replacement = f"{capture_stmt_with_decl} {serialize_stmt}"
             body_text = body_text[:es_start] + replacement + body_text[es_end:]
         else:
+            if is_void:
+                # Void calls cannot be embedded in expressions in valid Java — skip instrumentation
+                logger.warning("Skipping instrumentation of embedded void call: %s", call["full_call"])
+                continue
+
             # Embedded call: replace call with variable, then insert capture lines before the line
             call_start = call["_call_start_char"]
             call_end = call["_call_end_char"]
@@ -451,6 +491,8 @@ def _collect_calls(
                 if parent_type == "expression_statement":
                     es_start = parent.start_byte - prefix_len
                     es_end = parent.end_byte - prefix_len
+                object_node = node.child_by_field_name("object")
+                receiver = analyzer.get_node_text(object_node, wrapper_bytes) if object_node else "this"
                 out.append(
                     {
                         "start_byte": start,
@@ -461,6 +503,7 @@ def _collect_calls(
                         "in_complex": _is_inside_complex_expression(node),
                         "es_start_byte": es_start,
                         "es_end_byte": es_end,
+                        "receiver": receiver,
                     }
                 )
     for child in node.children:

codeflash/languages/java/remove_asserts.py

@@ -189,13 +189,15 @@ def __init__(
         qualified_name: str | None = None,
         analyzer: JavaAnalyzer | None = None,
         mode: str = "capture",
+        target_return_type: str = "",
     ) -> None:
         self.analyzer = analyzer or get_java_analyzer()
         self.func_name = function_name
         self.qualified_name = qualified_name or function_name
         self.invocation_counter = 0
         self._detected_framework: str | None = None
         self.mode = mode  # "capture" (default, instrumentation) or "strip" (clean display)
+        self.target_return_type = target_return_type
 
         # Precompile the assignment-detection regex to avoid recompiling on each call.
         self._assign_re = re.compile(r"(\w+(?:<[^>]+>)?)\s+(\w+)\s*=\s*$")
@@ -1062,7 +1064,7 @@ def _generate_replacement(self, assertion: AssertionMatch) -> str:
         if not assertion.target_calls:
             return ""
 
-        if self.mode == "strip":
+        if self.mode == "strip" or self.target_return_type == "void":
             return self._generate_strip_replacement(assertion)
 
         # Infer the return type from assertion context to avoid Object→primitive cast errors
@@ -1244,7 +1246,9 @@ def _extract_first_arg(self, args_str: str) -> str | None:
         return "".join(cur).rstrip()
 
 
-def transform_java_assertions(source: str, function_name: str, qualified_name: str | None = None) -> str:
+def transform_java_assertions(
+    source: str, function_name: str, qualified_name: str | None = None, target_return_type: str = ""
+) -> str:
     """Transform Java test code by removing assertions and capturing function calls.
 
     This is the main entry point for Java assertion transformation.
@@ -1253,12 +1257,15 @@ def transform_java_assertions(source: str, function_name: str, qualified_name: s
         source: The Java test source code.
         function_name: Name of the function being tested.
         qualified_name: Optional fully qualified name of the function.
+        target_return_type: Return type of the target function (e.g., "void", "int").
 
     Returns:
         Transformed source code with assertions replaced by capture statements.
 
     """
-    transformer = JavaAssertTransformer(function_name=function_name, qualified_name=qualified_name)
+    transformer = JavaAssertTransformer(
+        function_name=function_name, qualified_name=qualified_name, target_return_type=target_return_type
+    )
     return transformer.transform(source)
 
 

tests/test_languages/fixtures/java_tracer_e2e/pom.xml

@@ -11,7 +11,18 @@
         <maven.compiler.source>11</maven.compiler.source>
         <maven.compiler.target>11</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
+            <checkstyle.skip>true</checkstyle.skip>
+        <disable.checks>true</disable.checks>
+        <spotbugs.skip>true</spotbugs.skip>
+        <pmd.skip>true</pmd.skip>
+        <rat.skip>true</rat.skip>
+        <enforcer.skip>true</enforcer.skip>
+        <japicmp.skip>true</japicmp.skip>
+        <checkstyle.failOnViolation>false</checkstyle.failOnViolation>
+        <checkstyle.failsOnError>false</checkstyle.failsOnError>
+        <maven-checkstyle-plugin.failsOnError>false</maven-checkstyle-plugin.failsOnError>
+        <maven-checkstyle-plugin.failOnViolation>false</maven-checkstyle-plugin.failOnViolation>
+</properties>
 
     <dependencies>
         <dependency>
@@ -62,6 +73,26 @@
           </execution>
         </executions>
       </plugin>
-    </plugins>
+    <!-- codeflash-validation-skip -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                    <failOnViolation>false</failOnViolation>
+                    <failsOnError>false</failsOnError>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>com.github.spotbugs</groupId>
+                <artifactId>spotbugs-maven-plugin</artifactId>
+                <configuration><skip>true</skip></configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-pmd-plugin</artifactId>
+                <configuration><skip>true</skip></configuration>
+            </plugin>
+</plugins>
     </build>
 </project>