Fix type info for FQ class values in array append

When appending a fully qualified class (like com.example.MyClass.class)
to an existing class array annotation attribute:

1. Use JavaTemplate.builder() with dependsOn to provide a class stub
   so the created expression has proper type information
2. Use the FQ class name in the template so it can resolve against
   the stub
3. Add ShortenFullyQualifiedTypeReferences as doAfterVisit to shorten
   the FQ name to the simple name (MyClass.class)
4. Fix attributeNameOrValIsAlreadyPresent to handle FQ class names
   when checking for duplicates by comparing both the full string
   and the simplified class name
5. Fix maybeAddImport to use onlyIfReferenced=false for FQ classes
   (same as we did for enums)

Author: Jenson3210

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

@@ -23,6 +23,7 @@
 import org.openrewrite.Issue;
 import org.openrewrite.test.RewriteTest;
 import org.openrewrite.test.SourceSpec;
+import org.openrewrite.test.TypeValidation;
 
 import static org.openrewrite.java.Assertions.java;
 
@@ -2770,6 +2771,49 @@ public class A {}
         );
     }
 
+    @Test
+    void appendFullyQualifiedClassValueToExistingClassAttribute() {
+        rewriteRun(
+          spec -> spec.recipe(new AddOrUpdateAnnotationAttribute(
+            "org.example.Foo",
+            null,
+            "com.example.MyClass.class",
+            null,
+            null,
+            true
+          )).typeValidationOptions(TypeValidation.all()),
+          java(
+            """
+              package com.example;
+              public class MyClass {}
+              """
+          ),
+          java(
+            """
+              package org.example;
+              public @interface Foo {
+                  Class<?>[] value();
+              }
+              """
+          ),
+          java(
+            """
+              import org.example.Foo;
+
+              @Foo(Integer.class)
+              public class A {}
+              """,
+            """
+              import com.example.MyClass;
+              import org.example.Foo;
+
+              @Foo({Integer.class, MyClass.class})
+              public class A {}
+              """
+          )
+        );
+    }
+
     @Test
     void appendClassValueToExistingNamedClassAttribute() {
         rewriteRun(

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

@@ -99,7 +99,7 @@ public J.Annotation visitAnnotation(J.Annotation original, ExecutionContext ctx)
 
                 String newAttributeValue;
                 if (isFullyQualifiedClass()) {
-                    maybeAddImport(attributeValue.substring(0, attributeValue.length() - 6));
+                    maybeAddImport(attributeValue.substring(0, attributeValue.length() - 6), false);
                     newAttributeValue = attributeValue;
                 } else if (isFullyQualifiedEnumValue(a)) {
                     maybeAddImport(getEnumClassName(attributeValue), false);
@@ -152,6 +152,9 @@ public J.Annotation visitAnnotation(J.Annotation original, ExecutionContext ctx)
 
                 if (original != a) {
                     doAfterVisit(new SimplifySingleElementAnnotation().getVisitor());
+                    if (isFullyQualifiedClass()) {
+                        doAfterVisit(new ShortenFullyQualifiedTypeReferences().getVisitor());
+                    }
                 }
                 return maybeAutoFormat(original, a, ctx);
             }
@@ -299,8 +302,19 @@ private J.NewArray createNewArrayWithExistingAndNew(J.Annotation annotation, J.F
                 // Add new values, skipping duplicates - use template for non-string values
                 for (String attribute : newValues) {
                     if (!attributeNameOrValIsAlreadyPresent(initializer, singleton(attribute))) {
+                        JavaTemplate.Builder templateBuilder = JavaTemplate.builder("#{}");
+                        String templateValue = attribute;
+                        // For FQ classes, add stub so type info is resolved and use FQ name in template
+                        if (isFullyQualifiedClass()) {
+                            String fqClassName = attributeValue.substring(0, attributeValue.length() - 6);
+                            String packageName = fqClassName.substring(0, fqClassName.lastIndexOf('.'));
+                            String simpleName = fqClassName.substring(fqClassName.lastIndexOf('.') + 1);
+                            templateBuilder = templateBuilder.javaParser(JavaParser.fromJavaVersion()
+                                    .dependsOn("package " + packageName + "; public class " + simpleName + " {}"));
+                            templateValue = fqClassName + ".class";
+                        }
                         //noinspection ConstantConditions
-                        Expression newExpr = JavaTemplate.<J.Annotation>apply("#{}", getCursor(), annotation.getCoordinates().replaceArguments(), attribute)
+                        Expression newExpr = templateBuilder.build().<J.Annotation>apply(getCursor(), annotation.getCoordinates().replaceArguments(), templateValue)
                                 .getArguments().get(0).withPrefix(SINGLE_SPACE);
                         initializer.add(newExpr);
                     }
@@ -510,7 +524,17 @@ private boolean attributeNameOrValIsAlreadyPresent(Expression e, Collection<?> v
         } else if (e instanceof J.Literal) {
             return values.contains(((J.Literal) e).getValue() + "");
         } else if (e instanceof J.FieldAccess) {
-            return values.contains(e.toString());
+            J.FieldAccess fa = (J.FieldAccess) e;
+            String fullString = fa.toString();
+            if (values.contains(fullString)) {
+                return true;
+            }
+            // For class literals, also check the simple name (e.g., com.example.MyClass.class -> MyClass.class)
+            if (fullString.endsWith(".class") && fa.getTarget() instanceof J.FieldAccess) {
+                String simpleName = getFullyQualifiedClass(fullString);
+                return values.contains(simpleName);
+            }
+            return false;
         } else if (e instanceof J.NewArray) {
             List<Expression> initializer = ((J.NewArray) e).getInitializer();
             return (initializer == null && attributeValue == null) || (initializer != null && attributeNameOrValIsAlreadyPresent(initializer, values));