Add UseListOf and UseSetOf recipes (#974)

Add recipes to convert double-brace initialization of ArrayList and
HashSet to List.of() and Set.of() respectively for Java 10+. These
recipes complement the existing UseMapOf recipe.

Example transformation for UseListOf:
  new ArrayList<>() {{ add("a"); add("b"); }}
  becomes
  List.of("a", "b")

Example transformation for UseSetOf:
  new HashSet<>() {{ add("a"); add("b"); }}
  becomes
  Set.of("a", "b")

Fixes: moderneinc/customer-requests#1544

Author: jkschneider

src/main/java/org/openrewrite/java/migrate/util/UseListOf.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2024 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.util;
+
+import lombok.Getter;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.MethodMatcher;
+import org.openrewrite.java.search.UsesJavaVersion;
+import org.openrewrite.java.search.UsesMethod;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.Statement;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringJoiner;
+
+public class UseListOf extends Recipe {
+    private static final MethodMatcher NEW_ARRAY_LIST = new MethodMatcher("java.util.ArrayList <constructor>()", true);
+    private static final MethodMatcher LIST_ADD = new MethodMatcher("java.util.List add(..)", true);
+
+    @Getter
+    final String displayName = "Prefer `List.of(..)`";
+
+    @Getter
+    final String description = "Prefer `List.of(..)` instead of using `java.util.List#add(..)` in anonymous ArrayList initializers in Java 10 or higher. " +
+            "This recipe will not modify code where the List is later mutated since `List.of` returns an immutable list.";
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(
+                Preconditions.and(
+                        new UsesJavaVersion<>(10),
+                        new UsesMethod<>(NEW_ARRAY_LIST)),
+                new JavaVisitor<ExecutionContext>() {
+                    @Override
+                    public J visitNewClass(J.NewClass newClass, ExecutionContext ctx) {
+                        J.NewClass n = (J.NewClass) super.visitNewClass(newClass, ctx);
+                        J.Block body = n.getBody();
+                        if (NEW_ARRAY_LIST.matches(n) && body != null && body.getStatements().size() == 1) {
+                            Statement statement = body.getStatements().get(0);
+                            if (statement instanceof J.Block) {
+                                List<Expression> args = new ArrayList<>();
+                                StringJoiner listOf = new StringJoiner(", ", "List.of(", ")");
+                                for (Statement stat : ((J.Block) statement).getStatements()) {
+                                    if (!(stat instanceof J.MethodInvocation) || !LIST_ADD.matches((Expression) stat)) {
+                                        return n;
+                                    }
+                                    J.MethodInvocation add = (J.MethodInvocation) stat;
+                                    // List.add() takes only one argument
+                                    if (add.getArguments().size() != 1) {
+                                        return n;
+                                    }
+                                    args.add(add.getArguments().get(0));
+                                    listOf.add("#{any()}");
+                                }
+
+                                maybeRemoveImport("java.util.ArrayList");
+                                maybeAddImport("java.util.List");
+                                return JavaTemplate.builder(listOf.toString())
+                                        .contextSensitive()
+                                        .imports("java.util.List")
+                                        .build()
+                                        .apply(updateCursor(n), n.getCoordinates().replace(), args.toArray());
+                            }
+                        }
+
+                        return n;
+                    }
+                });
+    }
+
+}

src/main/java/org/openrewrite/java/migrate/util/UseSetOf.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2024 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.util;
+
+import lombok.Getter;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.MethodMatcher;
+import org.openrewrite.java.search.UsesJavaVersion;
+import org.openrewrite.java.search.UsesMethod;
+import org.openrewrite.java.tree.Expression;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.Statement;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringJoiner;
+
+public class UseSetOf extends Recipe {
+    private static final MethodMatcher NEW_HASH_SET = new MethodMatcher("java.util.HashSet <constructor>()", true);
+    private static final MethodMatcher SET_ADD = new MethodMatcher("java.util.Set add(..)", true);
+
+    @Getter
+    final String displayName = "Prefer `Set.of(..)`";
+
+    @Getter
+    final String description = "Prefer `Set.of(..)` instead of using `java.util.Set#add(..)` in anonymous HashSet initializers in Java 10 or higher. " +
+            "This recipe will not modify code where the Set is later mutated since `Set.of` returns an immutable set.";
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(
+                Preconditions.and(
+                        new UsesJavaVersion<>(10),
+                        new UsesMethod<>(NEW_HASH_SET)),
+                new JavaVisitor<ExecutionContext>() {
+                    @Override
+                    public J visitNewClass(J.NewClass newClass, ExecutionContext ctx) {
+                        J.NewClass n = (J.NewClass) super.visitNewClass(newClass, ctx);
+                        J.Block body = n.getBody();
+                        if (NEW_HASH_SET.matches(n) && body != null && body.getStatements().size() == 1) {
+                            Statement statement = body.getStatements().get(0);
+                            if (statement instanceof J.Block) {
+                                List<Expression> args = new ArrayList<>();
+                                StringJoiner setOf = new StringJoiner(", ", "Set.of(", ")");
+                                for (Statement stat : ((J.Block) statement).getStatements()) {
+                                    if (!(stat instanceof J.MethodInvocation) || !SET_ADD.matches((Expression) stat)) {
+                                        return n;
+                                    }
+                                    J.MethodInvocation add = (J.MethodInvocation) stat;
+                                    // Set.add() takes only one argument
+                                    if (add.getArguments().size() != 1) {
+                                        return n;
+                                    }
+                                    args.add(add.getArguments().get(0));
+                                    setOf.add("#{any()}");
+                                }
+
+                                maybeRemoveImport("java.util.HashSet");
+                                maybeAddImport("java.util.Set");
+                                return JavaTemplate.builder(setOf.toString())
+                                        .contextSensitive()
+                                        .imports("java.util.Set")
+                                        .build()
+                                        .apply(updateCursor(n), n.getCoordinates().replace(), args.toArray());
+                            }
+                        }
+
+                        return n;
+                    }
+                });
+    }
+
+}

src/main/resources/META-INF/rewrite/recipes.csv

@@ -418,6 +418,8 @@ maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.u
 maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.UseEnumSetOf,Prefer `EnumSet of(..)`,Prefer `EnumSet of(..)` instead of using `Set of(..)` when the arguments are enums in Java 9 or higher.,1,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,"[{""name"":""convertEmptySet"",""type"":""Boolean"",""displayName"":""Convert empty `Set.of()` to `EnumSet.noneOf()`"",""description"":""When true, converts `Set.of()` with no arguments to `EnumSet.noneOf()`. Default true."",""example"":""true""}]",
 maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.UseLocaleOf,Prefer `Locale.of(..)` over `new Locale(..)`,Prefer `Locale.of(..)` over `new Locale(..)` in Java 19 or higher.,1,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.UseMapOf,Prefer `Map.of(..)`,Prefer `Map.of(..)` instead of using `java.util.Map#put(..)` in Java 10 or higher.,1,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,
+maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.UseListOf,Prefer `List.of(..)`,Prefer `List.of(..)` instead of using `java.util.List#add(..)` in anonymous ArrayList initializers in Java 10 or higher. This recipe will not modify code where the List is later mutated since `List.of` returns an immutable list.,1,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,
+maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.UseSetOf,Prefer `Set.of(..)`,Prefer `Set.of(..)` instead of using `java.util.Set#add(..)` in anonymous HashSet initializers in Java 10 or higher. This recipe will not modify code where the Set is later mutated since `Set.of` returns an immutable set.,1,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.JavaUtilAPIs,Use modernized `java.util` APIs,Certain java util APIs have been introduced and are favored over previous APIs.,15,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.SequencedCollection,Adopt `SequencedCollection`,"Replace older code patterns with `SequencedCollection` methods, as per https://openjdk.org/jeps/431.",13,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-migrate-java,org.openrewrite.java.migrate.util.MigrateInflaterDeflaterToClose,Replace `Inflater` and `Deflater` `end()` calls with `close()`,"Replace `end()` method calls with `close()` method calls for `Inflater` and `Deflater` classes in Java 25+, as they now implement AutoCloseable.",7,,`java.util` APIs,Modernize,Java,,,Modernize your code to best use the project's current JDK version. Take advantage of newly available APIs and reduce the dependency of your code on third party dependencies where there is equivalent functionality in the Java standard library.,Basic building blocks for transforming Java code.,,