If any method signature in an @AutoValue class mentions @Nullable, copy that @Nullable to the parameter of equals(Object).

eamonnmcmanus · Google Java Core Libraries · commit 4d01ce625157 · 2021-03-23T14:19:16.000-07:00
This only works for `TYPE_USE` annotations, which is what everybody should be using these days.

RELNOTES=The parameter of `equals(Object)` is annotated with `@Nullable` if any method signature mentions `@Nullable`.
PiperOrigin-RevId: 364642711
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
@@ -15,9 +15,11 @@
  */
 package com.google.auto.value;
 
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
 import static com.google.common.truth.Truth8.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
 import static com.google.testing.compile.CompilationSubject.assertThat;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assume.assumeTrue;
@@ -153,6 +155,19 @@ public void testNullablePropertiesCanBeNull() {
         .isEqualTo("NullableProperties{nullableString=null, randomInt=23}");
   }
 
+  @Test
+  public void testEqualsParameterIsAnnotated() throws NoSuchMethodException {
+    // Sadly we can't rely on JDK 8 to handle type annotations correctly.
+    // Some versions do, some don't. So skip the test unless we are on at least JDK 9.
+    double javaVersion = Double.parseDouble(JAVA_SPECIFICATION_VERSION.value());
+    assume().that(javaVersion).isAtLeast(9.0);
+    Method equals =
+        NullableProperties.create(null, 23).getClass().getMethod("equals", Object.class);
+    AnnotatedType[] parameterTypes = equals.getAnnotatedParameterTypes();
+    assertThat(parameterTypes).hasLength(1);
+    assertThat(parameterTypes[0].getAnnotation(Nullable.class)).isNotNull();
+  }
+
   @AutoAnnotation
   static Nullable nullable() {
     return new AutoAnnotation_AutoValueJava8Test_nullable();
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfProcessor.java
@@ -56,6 +56,7 @@
 import java.util.OptionalInt;
 import java.util.Set;
 import java.util.function.Predicate;
+import java.util.stream.IntStream;
 import javax.annotation.processing.AbstractProcessor;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.annotation.processing.RoundEnvironment;
@@ -383,7 +384,7 @@ final ImmutableSet<Property> propertySet(
         (propertyMethod, returnType) -> {
           String propertyType =
               TypeEncoder.encodeWithAnnotations(
-                  returnType, getExcludedAnnotationTypes(propertyMethod));
+                  returnType, ImmutableList.of(), getExcludedAnnotationTypes(propertyMethod));
           String propertyName = methodToPropertyName.get(propertyMethod);
           String identifier = methodToIdentifier.get(propertyMethod);
           ImmutableList<String> fieldAnnotations =
@@ -432,7 +433,8 @@ final void defineSharedVarsForType(
     vars.toString = methodsToGenerate.containsKey(ObjectMethod.TO_STRING);
     vars.equals = methodsToGenerate.containsKey(ObjectMethod.EQUALS);
     vars.hashCode = methodsToGenerate.containsKey(ObjectMethod.HASH_CODE);
-    vars.equalsParameterType = equalsParameterType(methodsToGenerate);
+    Optional<DeclaredType> nullable = Nullables.nullableMentionedInMethods(methods);
+    vars.equalsParameterType = equalsParameterType(methodsToGenerate, nullable);
     vars.serialVersionUID = getSerialVersionUID(type);
   }
 
@@ -567,12 +569,9 @@ static Optional<String> nullableAnnotationFor(Element element, TypeMirror elemen
   }
 
   private static OptionalInt nullableAnnotationIndex(List<? extends AnnotationMirror> annotations) {
-    for (int i = 0; i < annotations.size(); i++) {
-      if (isNullable(annotations.get(i))) {
-        return OptionalInt.of(i);
-      }
-    }
-    return OptionalInt.empty();
+    return IntStream.range(0, annotations.size())
+        .filter(i -> isNullable(annotations.get(i)))
+        .findFirst();
   }
 
   private static boolean isNullable(AnnotationMirror annotation) {
@@ -706,14 +705,40 @@ private static Map<ObjectMethod, ExecutableElement> determineObjectMethodsToGene
    * Returns the encoded parameter type of the {@code equals(Object)} method that is to be
    * generated, or an empty string if the method is not being generated. The parameter type includes
    * any type annotations, for example {@code @Nullable}.
+   *
+   * @param methodsToGenerate the Object methods that are being generated
+   * @param nullable the type of a {@code @Nullable} type annotation that we have found, if any
    */
-  static String equalsParameterType(Map<ObjectMethod, ExecutableElement> methodsToGenerate) {
+  static String equalsParameterType(
+      Map<ObjectMethod, ExecutableElement> methodsToGenerate, Optional<DeclaredType> nullable) {
     ExecutableElement equals = methodsToGenerate.get(ObjectMethod.EQUALS);
     if (equals == null) {
       return ""; // this will not be referenced because no equals method will be generated
     }
     TypeMirror parameterType = equals.getParameters().get(0).asType();
-    return TypeEncoder.encodeWithAnnotations(parameterType);
+    // Add @Nullable if we know one and the parameter doesn't already have one.
+    // The @Nullable we add will be a type annotation, but if the parameter already has @Nullable
+    // then that might be a type annotation or an annotation on the parameter.
+    ImmutableList<AnnotationMirror> extraAnnotations =
+        nullable.isPresent() && !nullableAnnotationFor(equals, parameterType).isPresent()
+            ? ImmutableList.of(annotationMirror(nullable.get()))
+            : ImmutableList.of();
+    return TypeEncoder.encodeWithAnnotations(parameterType, extraAnnotations, ImmutableSet.of());
+  }
+
+  private static AnnotationMirror annotationMirror(DeclaredType annotationType) {
+    return new AnnotationMirror() {
+      @Override
+      public DeclaredType getAnnotationType() {
+        return annotationType;
+      }
+
+      @Override
+      public ImmutableMap<? extends ExecutableElement, ? extends AnnotationValue>
+          getElementValues() {
+        return ImmutableMap.of();
+      }
+    };
   }
 
   /**
diff --git a/value/src/main/java/com/google/auto/value/processor/Nullables.java b/value/src/main/java/com/google/auto/value/processor/Nullables.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 com.google.auto.value.processor;
+
+import static java.util.stream.Collectors.toList;
+
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.IntersectionType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.type.WildcardType;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+class Nullables {
+  /**
+   * Returns the type of a {@code @Nullable} type-annotation, if one is found anywhere in the
+   * signatures of the given methods.
+   */
+  static Optional<DeclaredType> nullableMentionedInMethods(Collection<ExecutableElement> methods) {
+    return methods.stream()
+        .flatMap(
+            method ->
+                Stream.concat(
+                    Stream.of(method.getReturnType()),
+                    method.getParameters().stream().map(Element::asType)))
+        .map(Nullables::nullableIn)
+        .filter(Optional::isPresent)
+        .findFirst()
+        .orElse(Optional.empty());
+  }
+
+  private static Optional<DeclaredType> nullableIn(TypeMirror type) {
+    return new NullableFinder().visit(type);
+  }
+
+  private static Optional<DeclaredType> nullableIn(List<? extends AnnotationMirror> annotations) {
+    return annotations.stream()
+        .map(AnnotationMirror::getAnnotationType)
+        .filter(t -> t.asElement().getSimpleName().contentEquals("Nullable"))
+        .findFirst();
+  }
+
+  private static class NullableFinder extends SimpleTypeVisitor8<Optional<DeclaredType>, Void> {
+    private final TypeMirrorSet visiting = new TypeMirrorSet();
+
+    NullableFinder() {
+      super(Optional.empty());
+    }
+
+    // Primitives can't be @Nullable so we don't check that.
+
+    @Override
+    public Optional<DeclaredType> visitDeclared(DeclaredType t, Void unused) {
+      if (!visiting.add(t)) {
+        return Optional.empty();
+      }
+      return nullableIn(t.getAnnotationMirrors())
+          .map(Optional::of)
+          .orElseGet(() -> visitAll(t.getTypeArguments()));
+    }
+
+    @Override
+    public Optional<DeclaredType> visitTypeVariable(TypeVariable t, Void unused) {
+      if (!visiting.add(t)) {
+        return Optional.empty();
+      }
+      return nullableIn(t.getAnnotationMirrors())
+          .map(Optional::of)
+          .orElseGet(() -> visitAll(ImmutableList.of(t.getUpperBound(), t.getLowerBound())));
+    }
+
+    @Override
+    public Optional<DeclaredType> visitArray(ArrayType t, Void unused) {
+      return nullableIn(t.getAnnotationMirrors())
+          .map(Optional::of)
+          .orElseGet(() -> visit(t.getComponentType()));
+    }
+
+    @Override
+    public Optional<DeclaredType> visitWildcard(WildcardType t, Void unused) {
+      return nullableIn(t.getAnnotationMirrors())
+          .map(Optional::of)
+          .orElseGet(
+              () ->
+                  visitAll(
+                      Stream.of(t.getExtendsBound(), t.getSuperBound())
+                          .filter(Objects::nonNull)
+                          .collect(toList())));
+    }
+
+    @Override
+    public Optional<DeclaredType> visitIntersection(IntersectionType t, Void unused) {
+      return nullableIn(t.getAnnotationMirrors())
+          .map(Optional::of)
+          .orElseGet(() -> visitAll(t.getBounds()));
+    }
+
+    private Optional<DeclaredType> visitAll(List<? extends TypeMirror> types) {
+      return types.stream()
+          .map(this::visit)
+          .filter(Optional::isPresent)
+          .findFirst()
+          .orElse(Optional.empty());
+    }
+  }
+
+  private Nullables() {}
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/TypeEncoder.java b/value/src/main/java/com/google/auto/value/processor/TypeEncoder.java
@@ -22,10 +22,12 @@
 import com.google.auto.common.MoreElements;
 import com.google.auto.common.MoreTypes;
 import com.google.auto.value.processor.MissingTypes.MissingTypeException;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.util.List;
 import java.util.OptionalInt;
 import java.util.Set;
+import java.util.function.Function;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.TypeElement;
@@ -97,20 +99,36 @@ static String encodeRaw(TypeMirror type) {
    * covers the details of annotation encoding.
    */
   static String encodeWithAnnotations(TypeMirror type) {
-    return encodeWithAnnotations(type, ImmutableSet.of());
+    return encodeWithAnnotations(type, ImmutableList.of(), ImmutableSet.of());
   }
 
   /**
    * Encodes the given type and its type annotations. The class comment for {@link TypeEncoder}
    * covers the details of annotation encoding.
    *
+   * @param extraAnnotations additional type annotations to include with the type
    * @param excludedAnnotationTypes annotations not to include in the encoding. For example, if
    *     {@code com.example.Nullable} is in this set then the encoding will not include this
    *     {@code @Nullable} annotation.
    */
-  static String encodeWithAnnotations(TypeMirror type, Set<TypeMirror> excludedAnnotationTypes) {
+  static String encodeWithAnnotations(
+      TypeMirror type,
+      ImmutableList<AnnotationMirror> extraAnnotations,
+      Set<TypeMirror> excludedAnnotationTypes) {
     StringBuilder sb = new StringBuilder();
-    return new AnnotatedEncodingTypeVisitor(excludedAnnotationTypes).visit2(type, sb).toString();
+    // A function that is equivalent to t.getAnnotationMirrors() except when the t in question is
+    // our starting type. In that case we also add extraAnnotations to the result.
+    Function<TypeMirror, List<? extends AnnotationMirror>> getTypeAnnotations =
+        t ->
+            (t == type)
+                ? ImmutableList.<AnnotationMirror>builder()
+                    .addAll(t.getAnnotationMirrors())
+                    .addAll(extraAnnotations)
+                    .build()
+                : t.getAnnotationMirrors();
+    return new AnnotatedEncodingTypeVisitor(excludedAnnotationTypes, getTypeAnnotations)
+        .visit2(type, sb)
+        .toString();
   }
 
   /**
@@ -308,9 +326,13 @@ void appendTypeArguments(DeclaredType type, StringBuilder sb) {}
    */
   private static class AnnotatedEncodingTypeVisitor extends EncodingTypeVisitor {
     private final Set<TypeMirror> excludedAnnotationTypes;
+    private final Function<TypeMirror, List<? extends AnnotationMirror>> getTypeAnnotations;
 
-    AnnotatedEncodingTypeVisitor(Set<TypeMirror> excludedAnnotationTypes) {
+    AnnotatedEncodingTypeVisitor(
+        Set<TypeMirror> excludedAnnotationTypes,
+        Function<TypeMirror, List<? extends AnnotationMirror>> getTypeAnnotations) {
       this.excludedAnnotationTypes = excludedAnnotationTypes;
+      this.getTypeAnnotations = getTypeAnnotations;
     }
 
     private void appendAnnotationsWithExclusions(
@@ -330,15 +352,15 @@ private void appendAnnotationsWithExclusions(
 
     @Override
     public StringBuilder visitPrimitive(PrimitiveType type, StringBuilder sb) {
-      appendAnnotationsWithExclusions(type.getAnnotationMirrors(), sb);
+      appendAnnotationsWithExclusions(getTypeAnnotations.apply(type), sb);
       // We can't just append type.toString(), because that will also have the annotation, but
       // without encoding.
       return sb.append(type.getKind().toString().toLowerCase());
     }
 
     @Override
     public StringBuilder visitTypeVariable(TypeVariable type, StringBuilder sb) {
-      appendAnnotationsWithExclusions(type.getAnnotationMirrors(), sb);
+      appendAnnotationsWithExclusions(getTypeAnnotations.apply(type), sb);
       return sb.append(type.asElement().getSimpleName());
     }
 
@@ -350,7 +372,7 @@ public StringBuilder visitTypeVariable(TypeVariable type, StringBuilder sb) {
     @Override
     public StringBuilder visitArray(ArrayType type, StringBuilder sb) {
       visit2(type.getComponentType(), sb);
-      List<? extends AnnotationMirror> annotationMirrors = type.getAnnotationMirrors();
+      List<? extends AnnotationMirror> annotationMirrors = getTypeAnnotations.apply(type);
       if (!annotationMirrors.isEmpty()) {
         sb.append(" ");
         appendAnnotationsWithExclusions(annotationMirrors, sb);
@@ -360,7 +382,7 @@ public StringBuilder visitArray(ArrayType type, StringBuilder sb) {
 
     @Override
     public StringBuilder visitDeclared(DeclaredType type, StringBuilder sb) {
-      List<? extends AnnotationMirror> annotationMirrors = type.getAnnotationMirrors();
+      List<? extends AnnotationMirror> annotationMirrors = getTypeAnnotations.apply(type);
       if (annotationMirrors.isEmpty()) {
         super.visitDeclared(type, sb);
       } else {
diff --git a/value/src/test/java/com/google/auto/value/processor/NullablesTest.java b/value/src/test/java/com/google/auto/value/processor/NullablesTest.java
