Improving support for appendArray when going from literal to array, either via single value or a comma-separated list of values

Author: steve-aom-elliott

rewrite-java-test/src/test/java/org/openrewrite/java/AddOrUpdateAnnotationAttributeTest.java

@@ -60,6 +60,37 @@ public class A {
         );
     }
 
+    @Test
+    void literalToListFromSingleValueUsingAppendArray() {
+        rewriteRun(
+          spec -> spec.recipe(new AddOrUpdateAnnotationAttribute("org.example.Foo", "bars", "xyz", null, null, true)),
+          //language=java
+          java(
+            """
+              package org.example;
+              public @interface Foo {
+                  String[] bars() default {};
+              }
+              """
+          ),
+          //language=java
+          java(
+            """
+              import org.example.Foo;
+
+              @Foo(bars = "abc")
+              public class A {}
+              """,
+            """
+              import org.example.Foo;
+
+              @Foo(bars = {"abc", "xyz"})
+              public class A {}
+              """
+          )
+        );
+    }
+
     @Test
     void addValueAttributeClass() {
         rewriteRun(
@@ -748,7 +779,7 @@ public class A {
             """
               import org.example.Foo;
 
-              @Foo(array = {"newTest1", "newTest2"})
+              @Foo(array = {"oldTest", "newTest1", "newTest2"})
               public class A {
               }
               """

rewrite-java/src/main/java/org/openrewrite/java/AddOrUpdateAnnotationAttribute.java

@@ -34,6 +34,7 @@
 import static java.util.Collections.*;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
 import static org.openrewrite.Tree.randomId;
 import static org.openrewrite.java.tree.Space.SINGLE_SPACE;
 import static org.openrewrite.marker.Markers.EMPTY;
@@ -171,6 +172,16 @@ public J.Annotation visitAnnotation(J.Annotation original, ExecutionContext ctx)
                     if (!valueMatches(exp, oldAttributeValue) || newAttributeValue.equals(((J.Literal) exp).getValueSource())) {
                         return as;
                     }
+                    if (TRUE.equals(appendArray) && attributeIsArray(annotation)) {
+                        List<Expression> updatedList = updateInitializer(annotation, singletonList(as.getAssignment()), getAttributeValues());
+                        Expression flattenedList = createAnnotationLiteralFromString(
+                                annotation,
+                                wrapValues(updatedList.stream()
+                                        .map(e -> ((J.Literal) e).getValueSource())
+                                        .collect(toList()), true)
+                        );
+                        return as.withAssignment(flattenedList);
+                    }
                     return as.withAssignment(createAnnotationLiteral(annotation, newAttributeValue));
                 }
                 if (exp instanceof J.FieldAccess) {
@@ -246,6 +257,12 @@ private Expression createAnnotationLiteral(J.Annotation annotation, String newAt
                         .getArguments().get(0);
             }
 
+            private Expression createAnnotationLiteralFromString(J.Annotation annotation, String updatedAttributeValue) {
+                //noinspection ConstantConditions
+                return JavaTemplate.<J.Annotation>apply("#{}", getCursor(), annotation.getCoordinates().replaceArguments(), updatedAttributeValue)
+                        .getArguments().get(0);
+            }
+
             private J.Assignment createAnnotationAssignment(J.Annotation annotation, String name, @Nullable Object parameter) {
                 //noinspection ConstantConditions
                 return (J.Assignment) JavaTemplate.<J.Annotation>apply(name + " = " + (parameter instanceof J ? "#{any()}" : "#{}"), getCursor(), annotation.getCoordinates().replaceArguments(), parameter)
@@ -324,7 +341,14 @@ private List<String> getAttributeValues() {
     }
 
     private String getAttributeValuesAsString() {
-        return getAttributeValues().stream().map(String::valueOf).collect(joining("\", \"", "{\"", "\"}"));
+        return wrapValues(getAttributeValues(), false);
+    }
+
+    private String wrapValues(List<@Nullable String> values, boolean quoteless) {
+        if (quoteless) {
+            return values.stream().map(String::valueOf).collect(joining(", ", "{", "}"));
+        }
+        return values.stream().map(String::valueOf).collect(joining("\", \"", "{\"", "\"}"));
     }
 
     private static boolean isAnnotationWithOnlyValueMethod(J.Annotation annotation) {