AddOrUpdateAnnotationAttribute respects appendArray with string literals (#6598)

* AddOrUpdateAnnotationAttribute respects appendArray with string literals

When appendArray=true and the existing annotation value is a string
literal (not already an array), the recipe now converts it to an array
and appends the new values instead of replacing.

Before: @foo(bars = "abc") + appendArray=true + value="xyz" → @foo(bars = "xyz")
After:  @foo(bars = "abc") + appendArray=true + value="xyz" → @foo(bars = {"abc", "xyz"})

Fixes moderneinc/customer-requests#1410

* Fix for test that somehow didn't run

Author: steve-aom-elliott

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

@@ -728,7 +728,8 @@ void arrayInputMoreThanOneInAnnotationLiteralAttribute() {
             "newTest1,newTest2",
             null,
             false,
-            true)),
+            false
+          )),
           java(
             """
               package org.example;
@@ -2365,4 +2366,120 @@ public class A {
         );
     }
 
+    @Test
+    void respectsAppendArrayWhenGoingFromLiteralToArraySingle() {
+        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 {};
+              }
+              """,
+            SourceSpec::skip
+          ),
+          //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 respectsAppendArrayWhenGoingFromLiteralToArrayMulti() {
+        rewriteRun(
+          spec -> spec.recipe(new AddOrUpdateAnnotationAttribute(
+            "org.example.Foo",
+            "bars",
+            "xyz,def",
+            null,
+            null,
+            true
+          )),
+          //language=java
+          java(
+            """
+              package org.example;
+              public @interface Foo {
+                  String[] bars() default {};
+              }
+              """,
+            SourceSpec::skip
+          ),
+          //language=java
+          java(
+            """
+              import org.example.Foo;
+
+              @Foo(bars = "abc")
+              public class A {}
+              """,
+            """
+              import org.example.Foo;
+
+              @Foo(bars = {"abc", "xyz", "def"})
+              public class A {}
+              """
+          )
+        );
+    }
+
+    @Test
+    void respectsAppendArrayWhenGoingFromImplicitLiteralValueToArray() {
+        rewriteRun(
+          spec -> spec.recipe(new AddOrUpdateAnnotationAttribute(
+            "org.example.Foo",
+            null,
+            "xyz",
+            null,
+            null,
+            true
+          )),
+          //language=java
+          java(
+            """
+              package org.example;
+              public @interface Foo {
+                  String[] value() default {};
+              }
+              """,
+            SourceSpec::skip
+          ),
+          //language=java
+          java(
+            """
+              import org.example.Foo;
+
+              @Foo("abc")
+              public class A {}
+              """,
+            """
+              import org.example.Foo;
+
+              @Foo({"abc", "xyz"})
+              public class A {}
+              """
+          )
+        );
+    }
 }

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

@@ -171,6 +171,10 @@ public J.Annotation visitAnnotation(J.Annotation original, ExecutionContext ctx)
                     if (!valueMatches(exp, oldAttributeValue) || newAttributeValue.equals(((J.Literal) exp).getValueSource())) {
                         return as;
                     }
+                    // If appendArray is true and attribute is an array, convert literal to array and append
+                    if (TRUE.equals(appendArray) && attributeIsArray(annotation)) {
+                        return as.withAssignment(createNewArrayWithExistingAndNew(annotation, (J.Literal) exp, getAttributeValues()));
+                    }
                     return as.withAssignment(createAnnotationLiteral(annotation, newAttributeValue));
                 }
                 if (exp instanceof J.FieldAccess) {
@@ -196,6 +200,10 @@ public J.Annotation visitAnnotation(J.Annotation original, ExecutionContext ctx)
                     if (!valueMatches(literal, oldAttributeValue) || newAttributeValue.equals(literal.getValueSource())) {
                         return literal;
                     }
+                    // If appendArray is true and attribute is an array, convert literal to array and append
+                    if (TRUE.equals(appendArray) && attributeIsArray(annotation)) {
+                        return createNewArrayWithExistingAndNew(annotation, literal, getAttributeValues());
+                    }
                     return createAnnotationLiteral(annotation, newAttributeValue);
                 }
                 if (oldAttributeValue == null && newAttributeValue != null) {
@@ -251,6 +259,23 @@ private J.Assignment createAnnotationAssignment(J.Annotation annotation, String
                 return (J.Assignment) JavaTemplate.<J.Annotation>apply(name + " = " + (parameter instanceof J ? "#{any()}" : "#{}"), getCursor(), annotation.getCoordinates().replaceArguments(), parameter)
                         .getArguments().get(0);
             }
+
+            private J.NewArray createNewArrayWithExistingAndNew(J.Annotation annotation, J.Literal existingLiteral, List<String> newValues) {
+                List<Expression> initializer = new ArrayList<>();
+                // Add the existing literal value first
+                initializer.add(existingLiteral.withPrefix(SINGLE_SPACE));
+                // Add new values, skipping duplicates
+                for (String attribute : newValues) {
+                    if (!attributeNameOrValIsAlreadyPresent(initializer, singleton(attribute))) {
+                        initializer.add(new J.Literal(randomId(), SINGLE_SPACE, EMPTY, attribute, maybeQuoteStringArgument(annotation, attribute), null, JavaType.Primitive.String));
+                    }
+                }
+                // Use a template to create the array structure, then replace the initializer
+                //noinspection ConstantConditions
+                J.NewArray template = (J.NewArray) JavaTemplate.<J.Annotation>apply("{#{any()}}", getCursor(), annotation.getCoordinates().replaceArguments(), existingLiteral)
+                        .getArguments().get(0);
+                return template.withInitializer(initializer);
+            }
         });
     }