Merge branch 'main' into run-ci-on-java-25

Author: timtebeek

src/main/java/org/openrewrite/java/migrate/io/ReplaceSystemOutWithIOPrint.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.migrate.io;
+
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.MethodMatcher;
+import org.openrewrite.java.search.UsesMethod;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.TypeUtils;
+
+public class ReplaceSystemOutWithIOPrint extends Recipe {
+
+    @Override
+    public String getDisplayName() {
+        return "Migrate `System.out.print` to Java 25 IO utility class";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Replace `System.out.print()`, `System.out.println()` with `IO.print()` and `IO.println()`. " +
+                "Migrates to the new IO utility class introduced in Java 25.";
+    }
+
+    private static final MethodMatcher SYSTEM_OUT_PRINT = new MethodMatcher("java.io.PrintStream print(..)");
+    private static final MethodMatcher SYSTEM_OUT_PRINTLN = new MethodMatcher("java.io.PrintStream println(..)");
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(
+                Preconditions.or(
+                        new UsesMethod<>(SYSTEM_OUT_PRINT),
+                        new UsesMethod<>(SYSTEM_OUT_PRINTLN)
+                ),
+                new JavaIsoVisitor<ExecutionContext>() {
+                    @Override
+                    public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                        J.MethodInvocation m = super.visitMethodInvocation(method, ctx);
+                        if (!isSystemOutMethod(m)) {
+                            return m;
+                        }
+                        String methodName = m.getName().getSimpleName();
+                        return m.getArguments().isEmpty() ?
+                                JavaTemplate.builder("IO.#{}()").build()
+                                        .apply(getCursor(), m.getCoordinates().replace(), methodName) :
+                                JavaTemplate.builder("IO.#{}(#{any()})").build()
+                                        .apply(getCursor(), m.getCoordinates().replace(), methodName, m.getArguments().get(0));
+                    }
+
+                    private boolean isSystemOutMethod(J.MethodInvocation mi) {
+                        if (SYSTEM_OUT_PRINT.matches(mi) || SYSTEM_OUT_PRINTLN.matches(mi)) {
+                            Expression expression = mi.getSelect();
+                            if (expression instanceof J.FieldAccess) {
+                                return isSystemOut(((J.FieldAccess) expression).getName());
+                            }
+                            if (expression instanceof J.Identifier) {
+                                maybeRemoveImport("java.lang.System.out");
+                                return isSystemOut((J.Identifier) expression);
+                            }
+                        }
+                        return false;
+                    }
+
+                    private boolean isSystemOut(J.Identifier identifier) {
+                        return "out".equals(identifier.getSimpleName()) &&
+                                identifier.getFieldType() != null &&
+                                TypeUtils.isAssignableTo("java.lang.System", identifier.getFieldType().getOwner());
+                    }
+                });
+    }
+}

src/main/java/org/openrewrite/java/migrate/lang/MigrateMainMethodToInstanceMain.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.migrate.lang;
+
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.search.UsesJavaVersion;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
+import org.openrewrite.java.tree.TypeUtils;
+import org.openrewrite.staticanalysis.VariableReferences;
+
+import static java.util.Collections.emptyList;
+
+public class MigrateMainMethodToInstanceMain extends Recipe {
+    @Override
+    public String getDisplayName() {
+        return "Migrate `public static void main(String[] args)` to instance `void main()`";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Migrate `public static void main(String[] args)` method to instance `void main()` method when the `args` parameter is unused, as supported by JEP 512 in Java 25+.";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(new UsesJavaVersion<>(25), new JavaIsoVisitor<ExecutionContext>() {
+            @Override
+            public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) {
+                J.MethodDeclaration md = super.visitMethodDeclaration(method, ctx);
+
+                // Check if this is a main method: public static void main(String[] args)
+                if (!"main".equals(md.getSimpleName()) ||
+                        md.getReturnTypeExpression() == null ||
+                        md.getReturnTypeExpression().getType() != JavaType.Primitive.Void ||
+                        !md.hasModifier(J.Modifier.Type.Public) ||
+                        !md.hasModifier(J.Modifier.Type.Static) ||
+                        md.getParameters().size() != 1 ||
+                        !(md.getParameters().get(0) instanceof J.VariableDeclarations) ||
+                        md.getBody() == null) {
+                    return md;
+                }
+
+                // Check if parameter is String[] type
+                J.VariableDeclarations param = (J.VariableDeclarations) md.getParameters().get(0);
+                JavaType paramType = param.getType();
+                if (!TypeUtils.isOfClassType(paramType, "java.lang.String") || !(paramType instanceof JavaType.Array)) {
+                    return md;
+                }
+
+                // Remove the parameter if unused
+                J.Identifier variableName = param.getVariables().get(0).getName();
+                if (VariableReferences.findRhsReferences(md.getBody(), variableName).isEmpty()) {
+                    md = md.withParameters(emptyList());
+                }
+                return md.withReturnTypeExpression(md.getReturnTypeExpression().withPrefix(md.getModifiers().get(0).getPrefix()))
+                        .withModifiers(emptyList());
+            }
+        });
+    }
+
+}

src/main/resources/META-INF/rewrite/examples.yml

@@ -3896,6 +3896,25 @@ examples:
     language: java
 ---
 type: specs.openrewrite.org/v1beta/example
+recipeName: org.openrewrite.java.migrate.io.ReplaceSystemOutWithIOPrint
+examples:
+- description: ''
+  sources:
+  - before: |
+      class Example {
+          void test() {
+              System.out.print("Hello");
+          }
+      }
+    after: |
+      class Example {
+          void test() {
+              IO.print("Hello");
+          }
+      }
+    language: java
+---
+type: specs.openrewrite.org/v1beta/example
 recipeName: org.openrewrite.java.migrate.jacoco.UpgradeJaCoCo
 examples:
 - description: ''
@@ -7479,6 +7498,30 @@ examples:
     language: java
 ---
 type: specs.openrewrite.org/v1beta/example
+recipeName: org.openrewrite.java.migrate.util.MigrateStringReaderToReaderOf
+examples:
+- description: ''
+  sources:
+  - before: |
+      import java.io.Reader;
+      import java.io.StringReader;
+
+      class Test {
+          void test(String content) {
+              Reader reader = new StringReader(content);
+          }
+      }
+    after: |
+      import java.io.Reader;
+
+      class Test {
+          void test(String content) {
+              Reader reader = Reader.of(content);
+          }
+      }
+    language: java
+---
+type: specs.openrewrite.org/v1beta/example
 recipeName: org.openrewrite.java.migrate.util.OptionalStreamRecipe
 examples:
 - description: ''

src/main/resources/META-INF/rewrite/java-version-25.yml

@@ -30,6 +30,8 @@ recipeList:
       version: 25
   - org.openrewrite.github.SetupJavaUpgradeJavaVersion:
       minimumJavaMajorVersion: 25
+  - org.openrewrite.java.migrate.io.ReplaceSystemOutWithIOPrint
+  - org.openrewrite.java.migrate.lang.MigrateMainMethodToInstanceMain
   - org.openrewrite.java.migrate.lang.MigrateProcessWaitForDuration
   - org.openrewrite.java.migrate.lang.ReplaceUnusedVariablesWithUnderscore
   - org.openrewrite.java.migrate.util.MigrateInflaterDeflaterToClose