Fix type-use annotation duplication on nested classes and arrays

Type-use annotations placed at the beginning of a return type (e.g. `@Nullable
Enclosing.Inner` or `@Nullable byte[]`) are associated with the left-most
type—the enclosing class type and array component type, respectively.

AutoValue's getReturnTypeAnnotations previously only checked annotations on the
root return type (e.g. `Inner` or `byte[]`), failing to check annotations on
the left-most type as return type. As a result, it treated them as method
declaration annotations and duplicated them onto the generated method.

This fix updates getReturnTypeAnnotations to inspect the left-most type
(unwrapping enclosing declared types and array component types) so type
annotations are correctly excluded from being copied to method declarations.

RELNOTES=n/a
PiperOrigin-RevId: 960390407

Author: cushon

value/src/main/java/com/google/auto/value/processor/AnnotatedTypeMirror.java

@@ -15,12 +15,16 @@
  */
 package com.google.auto.value.processor;
 
+import static com.google.auto.common.MoreTypes.asArray;
+import static com.google.auto.common.MoreTypes.asDeclared;
+
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
 import java.util.Objects;
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
+import org.jspecify.annotations.Nullable;
 
 /**
  * A {@link TypeMirror} and associated annotations.
@@ -89,6 +93,41 @@ public String toString() {
     return annotations.isEmpty() ? rewrittenType.toString() : annotations + " " + rewrittenType;
   }
 
+  @Nullable AnnotatedTypeMirror getEnclosingType() {
+    if (originalType.getKind().equals(TypeKind.DECLARED)) {
+      TypeMirror originalEnclosing = EclipseHack.getEnclosingType(asDeclared(originalType));
+      if (originalEnclosing.getKind().equals(TypeKind.DECLARED)) {
+        TypeMirror rewrittenEnclosing = EclipseHack.getEnclosingType(asDeclared(rewrittenType));
+        return new AnnotatedTypeMirror(originalEnclosing, rewrittenEnclosing);
+      }
+    }
+    return null;
+  }
+
+  @Nullable AnnotatedTypeMirror getComponentType() {
+    if (originalType.getKind().equals(TypeKind.ARRAY)) {
+      TypeMirror originalComponent = asArray(originalType).getComponentType();
+      TypeMirror rewrittenComponent = asArray(rewrittenType).getComponentType();
+      return new AnnotatedTypeMirror(originalComponent, rewrittenComponent);
+    }
+    return null;
+  }
+
+  AnnotatedTypeMirror leftMostType() {
+    AnnotatedTypeMirror cur = this;
+    while (cur.getKind().equals(TypeKind.ARRAY)) {
+      cur = cur.getComponentType();
+    }
+    while (cur.getKind().equals(TypeKind.DECLARED)) {
+      AnnotatedTypeMirror enclosing = cur.getEnclosingType();
+      if (enclosing == null) {
+        break;
+      }
+      cur = enclosing;
+    }
+    return cur;
+  }
+
   @Override
   public boolean equals(Object obj) {
     if (obj instanceof AnnotatedTypeMirror) {

value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java

@@ -1236,7 +1236,9 @@ ImmutableList<AnnotationMirror> propertyMethodAnnotations(
 
     // We need to exclude type annotations from the ones being output on the method, since
     // they will be output as part of the method's return type.
-    Set<String> returnTypeAnnotations = getReturnTypeAnnotations(method, a -> true);
+    AnnotatedTypeMirror returnType =
+        MethodSignature.asMemberOf(typeUtils(), type, method).returnType();
+    Set<String> returnTypeAnnotations = getReturnTypeAnnotations(returnType, a -> true);
     Set<String> excluded = union(excludedAnnotations, returnTypeAnnotations);
     return annotationsToCopy(type, method, excluded);
   }
@@ -1253,10 +1255,12 @@ final ImmutableListMultimap<ExecutableElement, AnnotationMirror> propertyFieldAn
 
   private ImmutableList<AnnotationMirror> propertyFieldAnnotations(
       TypeElement type, ExecutableElement method) {
+    AnnotatedTypeMirror returnType =
+        MethodSignature.asMemberOf(typeUtils(), type, method).returnType();
     // We need to exclude type annotations from the ones being output on the method, since
     // they will be output as part of the field's type.
     Set<String> returnTypeAnnotations =
-        getReturnTypeAnnotations(method, this::annotationAppliesToFields);
+        getReturnTypeAnnotations(returnType, this::annotationAppliesToFields);
     if (!hasAnnotationMirror(method, COPY_ANNOTATIONS_NAME)) {
       // If there's no @CopyAnnotations, we will still copy a @Nullable annotation, if (1) it is not
       // a TYPE_USE annotation (those appear as part of the type in the generated code) and (2) it
@@ -1295,9 +1299,19 @@ private ImmutableList<AnnotationMirror> propertyFieldAnnotations(
     return annotationsToCopy(type, method, excluded);
   }
 
+  /**
+   * Returns annotations that appear at the start of the given method return type. For example, if
+   * the method is {@code abstract @NotNull Outer.@Nullable Inner foo()} then the method will return
+   * a set containing {@code @NotNull}. This is to prevent outputting {@code @NotNull} a second time
+   * if, for example, that annotation targets methods as well as types. Normally we copy annotations
+   * from abstract methods to their implementations, but here we would not want to because we are
+   * already outputting {@code @NotNull} as part of the return type. In the example, we don't need
+   * to return {@code @Nullable} because it is unambiguously a type annotation and cannot be
+   * interpreted as applying to the method.
+   */
   private static Set<String> getReturnTypeAnnotations(
-      ExecutableElement method, Predicate<TypeElement> typeFilter) {
-    return method.getReturnType().getAnnotationMirrors().stream()
+      AnnotatedTypeMirror methodReturnType, Predicate<TypeElement> typeFilter) {
+    return methodReturnType.leftMostType().annotations().stream()
         .map(a -> a.getAnnotationType().asElement())
         .map(MoreElements::asType)
         .filter(typeFilter)

value/src/main/java/com/google/auto/value/processor/TypeEncoder.java

@@ -330,13 +330,17 @@ void appendTypeName(DeclaredType type, StringBuilder sb) {
         // add them with appendTypeArguments below. Of course, it's more usual for the outer class
         // not to have type arguments, but we'll still follow this path if the nested class is an
         // inner (not static) class.
-        visit2(enclosing, sb);
+        visitEnclosingDeclared(MoreTypes.asDeclared(enclosing), sb);
         sb.append(".").append(type.asElement().getSimpleName());
       } else {
         sb.append('`').append(className(type)).append('`');
       }
     }
 
+    void visitEnclosingDeclared(DeclaredType type, StringBuilder sb) {
+      visit2(type, sb);
+    }
+
     void appendTypeArguments(DeclaredType type, StringBuilder sb) {
       List<? extends TypeMirror> arguments = type.getTypeArguments();
       if (!arguments.isEmpty()) {
@@ -465,11 +469,14 @@ public StringBuilder visitDeclared(DeclaredType type, StringBuilder sb) {
       return sb;
     }
 
-    private void visitEnclosingDeclared(DeclaredType enclosing, StringBuilder sb) {
+    @Override
+    void visitEnclosingDeclared(DeclaredType enclosing, StringBuilder sb) {
       List<? extends AnnotationMirror> annotationMirrors = getTypeAnnotations.apply(enclosing);
-      // Enclosing instances should NEVER have @NotNull annotations.
+      // Enclosing instances should NEVER have @NotNull or @Nullable annotations.
       annotationMirrors =
-          annotationMirrors.stream().filter(a -> !Nullables.isNonNull(a)).collect(toList());
+          annotationMirrors.stream()
+              .filter(a -> !Nullables.isNonNull(a) && !Nullables.isNullable(a))
+              .collect(toList());
       if (annotationMirrors.isEmpty()) {
         super.visitDeclared(enclosing, sb);
       } else {

value/src/test/java/com/google/auto/value/processor/AutoValueCompilationTest.java

@@ -4322,13 +4322,27 @@ public void notNullTypeUseAnnotationOnOuterClass() {
             "class Outer {",
             "  class Inner {}",
             "}");
-    // TODO(b/540040170): Fix the duplicate annotation bug that causes compilation failure.
     Compilation compilation =
         javac()
             .withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
             .compile(javaFileObject);
+    assertThat(compilation).succeeded();
     assertThat(compilation)
-        .hadErrorContaining("foo.bar.Baz.NotNull is not a repeatable annotation");
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .contains(
+            "  @Override\n"
+                + "  Outer.Inner inner() {\n"
+                + "    return inner;\n"
+                + "  }\n");
+    assertThat(compilation)
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .doesNotContain("@Baz.NotNull\n  @Override");
+    assertThat(compilation)
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .contains("private Outer.@Nullable Inner inner;");
   }
 
   @Test
@@ -4412,13 +4426,27 @@ public void nullableTypeUseAnnotationOnOuterClass() {
             "class Outer {",
             "  class Inner {}",
             "}");
-    // TODO(b/540040170): Fix the duplicate annotation bug that causes compilation failure.
     Compilation compilation =
         javac()
             .withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
             .compile(javaFileObject);
+    assertThat(compilation).succeeded();
     assertThat(compilation)
-        .hadErrorContaining("foo.bar.Baz.Nullable is not a repeatable annotation");
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .contains(
+            "  @Override\n"
+                + "  Outer.Inner inner() {\n"
+                + "    return inner;\n"
+                + "  }\n");
+    assertThat(compilation)
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .doesNotContain("@Baz.Nullable\n  @Override");
+    assertThat(compilation)
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .contains("private Outer.Inner inner;");
   }
 
   @Test
@@ -4453,13 +4481,20 @@ public void notNullTypeUseAnnotationOnArray() {
             "    public abstract Baz build();",
             "  }",
             "}");
-    // TODO(b/540040170): Fix the duplicate annotation bug that causes compilation failure.
     Compilation compilation =
         javac()
             .withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
             .compile(javaFileObject);
+    assertThat(compilation).succeeded();
     assertThat(compilation)
-        .hadErrorContaining("foo.bar.Baz.NotNull is not a repeatable annotation");
+        .generatedSourceFile("foo.bar.AutoValue_Baz")
+        .contentsAsUtf8String()
+        .contains(
+            "  @SuppressWarnings(\"mutable\")\n"
+                + "  @Override\n"
+                + "  @Baz.NotNull byte[] bytes() {\n"
+                + "    return bytes;\n"
+                + "  }\n");
   }
 
   private static String sorted(String... imports) {