Bug and suggested fix.`ReplaceSystemOutWithIOPrint` corrupts syntax when method arguments have bounded or generic return types.

Start with ReplaceSystemOutWithIOPrint.java and its ReplaceSystemOutWithIOPrintTest.java tests. Run the focused test class, then add the supplied generic method invocation reproducer and check that the transformed output preserves the invocation. Done means the regression test passes without compiler placeholder artifacts.

I checked out all relevant OpenRewrite repo's, fed the AI with existing recipe name and a very careful description. Antigravity with Vertex / Gemini was then tasked to check and test. .Also to create a ticket for it, using your default template. The result is shown beneath.

What version of OpenRewrite are you using?

• Release 8.9.30
• rewrite-maven-plugin: 6.50.0
• rewrite-migrate-java: 3.49.0
• JDK: Java 25 (Temurin-25.0.4.1+1 LTS)

How are you running OpenRewrite?

Maven plugin (mvn org.openrewrite.maven:rewrite-maven-plugin:6.49.0:run) running the recipe org.openrewrite.java.migrate.io.ReplaceSystemOutWithIOPrint (via org.openrewrite.java.migrate.UpgradeToJava25).

What is the smallest, simplest way to reproduce the problem?

When ReplaceSystemOutWithIOPrint runs on a System.out.println(expr) call where the argument has a generic/bounded return type (such as Jackson's <T extends TreeNode> T readValueAsTree()), JavaTemplate.apply("IO.#{}(#{any()})", ...) fails synthetic parameter type attribution (__p1__).

Here is a ready-to-run regression test to add to ReplaceSystemOutWithIOPrintTest.java:

@Test
void replaceSystemOutPrintlnGenericMethodInvocation() {
    rewriteRun(
      java(
        """
          interface TreeNode {}
          interface Parser {
              <T extends TreeNode> T readValueAsTree();
          }
          class Example {
              void test(Parser p) {
                  System.out.println(p.readValueAsTree());
              }
          }
          """,
        """
          interface TreeNode {}
          interface Parser {
              <T extends TreeNode> T readValueAsTree();
          }
          class Example {
              void test(Parser p) {
                  IO.println(p.readValueAsTree());
              }
          }
          """
      )
    );
}

What did you expect to see?

The generic invocation should be preserved cleanly in the transformed output:

class Example {
    void test(Parser p) {
        IO.println(p.readValueAsTree());
    }
}

What did you see instead?

Compiler placeholder artifacts (__P__.<error>) leak directly into the generated source file:

class Example {
    void test(Parser p) {
        IO.println(__P__.<error> & TreeNode > pg.String & TreeNode>/*__p1__*/p());
    }
}

When run against real application code using Jackson (System.out.println(p.readValueAsTree())), the recipe produces:

IO.println(__P__.<error> & com .fasterxml.jackson.core.TreeNode >/*__p1__*/p());

which subsequently causes javac compilation failures (<identifier> expected, illegal start of expression).

What is the full stack trace of any errors you encountered?

org.opentest4j.AssertionFailedError: [Unexpected result in "TreeNode.java":
expected: 
  IO.println(p.readValueAsTree());
but was: 
  IO.println(__P__.<error> & TreeNode > pg.String & TreeNode>/*__p1__*/p());
]
    at app//org.openrewrite.test.RewriteTest.assertContentEquals(RewriteTest.java:702)
    at app//org.openrewrite.test.RewriteTest.rewriteRun(RewriteTest.java:584)
    at app//org.openrewrite.test.RewriteTest.rewriteRun(RewriteTest.java:159)
    at app//org.openrewrite.test.RewriteTest.rewriteRun(RewriteTest.java:154)
    at app//org.openrewrite.java.migrate.io.ReplaceSystemOutWithIOPrintTest.replaceSystemOutPrintlnGenericMethodInvocation(ReplaceSystemOutWithIOPrintTest.java:292)

Are you interested in contributing a fix to OpenRewrite?

Yes! We have already implemented and validated the fix locally.

Root Cause:
In ReplaceSystemOutWithIOPrint.java:

String methodName = m.getName().getSimpleName();
return m.getArguments().isEmpty() ?
        JavaTemplate.apply( "IO.#{}()", getCursor(), m.getCoordinates().replace(), methodName ) :
        JavaTemplate.apply( "IO.#{}(#{any()})", getCursor(), m.getCoordinates().replace(), methodName, m.getArguments().get( 0 ) );

Re-templating the arguments via JavaTemplate re-evaluates the argument's type through synthetic parameters (__p1__), which breaks on bounded type variables / intersection types.

Proposed Solution:
Since method names (print/println) and signatures are identical between System.out and IO, re-templating arguments is unnecessary. Directly replacing m.getSelect() with an IO identifier leaves the arguments AST untouched:

diff --git a/src/main/java/org/openrewrite/java/migrate/io/ReplaceSystemOutWithIOPrint.java b/src/main/java/org/openrewrite/java/migrate/io/ReplaceSystemOutWithIOPrint.java
index b8960f72..268a731d 100644
--- a/src/main/java/org/openrewrite/java/migrate/io/ReplaceSystemOutWithIOPrint.java
+++ b/src/main/java/org/openrewrite/java/migrate/io/ReplaceSystemOutWithIOPrint.java
@@ -51,13 +56,15 @@ public class ReplaceSystemOutWithIOPrint extends Recipe {
                     @Override
                     public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
                         J.MethodInvocation m = super.visitMethodInvocation(method, ctx);
-                        if (!isSystemOutMethod(m)) {
+                        if (!isSystemOutMethod(m) || m.getSelect() == null) {
                             return m;
                         }
-                        String methodName = m.getName().getSimpleName();
-                        return m.getArguments().isEmpty() ?
-                                JavaTemplate.apply( "IO.#{}()", getCursor(), m.getCoordinates().replace(), methodName ) :
-                                JavaTemplate.apply( "IO.#{}(#{any()})", getCursor(), m.getCoordinates().replace(), methodName, m.getArguments().get( 0 ) );
+                        JavaType.FullyQualified ioType = JavaType.ShallowClass.build("java.lang.IO");
+                        J.Identifier ioIdent = new J.Identifier(Tree.randomId(), m.getSelect().getPrefix(), Markers.EMPTY, emptyList(), "IO", ioType, null);
+                        JavaType.Method methodType = m.getMethodType() != null ? m.getMethodType().withDeclaringType(ioType) : null;
+                        return m.withSelect(ioIdent).withMethodType(methodType);
                     }

Testing & Verification performed:

• ./gradlew test --tests org.openrewrite.java.migrate.io.ReplaceSystemOutWithIOPrintTest: All 12 unit tests pass 100% green (including all existing tests and the new generic reproducer test).
• End-to-end application verification: Verified on downstream project under Java 25 (mvn test-compile and mvn test pass with 0 errors).