Make the guava-android copy of NullPointerTester read type-use annotations when they're available.

They're never available under an Android VM, but we also test guava-android under a JRE (which is always Java 8+ now, which makes our implementation job a bit easier), so the annotations _are_ available there.

This is a step toward letting us [use type-use annotations more widely in Guava](jspecify/jspecify#239). In particular, it unblocks cl/521011962 (which in turn reduces the number of merge conflicts we'll see when using type-use annotations in our tests), and it helps our other testing of type-use annotations in Guava.

In order to implement this, I copied two methods that were previously only available in guava-jre to make them also available in guava-android for `NullPointerTester` there: `Invokable.getAnnotatedReturnType()` and `Parameter.getAnnotatedType()`. Those methods do not work under and Android VM (where, again, type-use annotations aren't available), but they're useful for running our tests under a JRE.

FYI: We did see one project that needed some new `-dontwarn` lines in [our Proguard config](#2117) as a result of this CL. But we expect this to be unlikely, especially since reflection is typically a bad idea under Android. (An alternative approach would be for us to expose two _new_ methods that are similar to `getAnnotatedReturnType()` and `getAnnotatedType()` but that declare their return type as plain `Object`. That would be safer, but I think there's actually more value in testing the more aggressive approach: We'd like to someday be more aggressive about adding APIs that use Java 8+ types in guava-android, so it's nice to test them on low-stakes `@Beta` APIs that shouldn't be used from Android to begin with.)

On the plus side, we no longer need to perform reflection on account of j2objc: As planned in cl/367051816, j2objc was subsequently updated in cl/367072772 to contain stub implementations of the necessary `TypeVariable` methods.

RELNOTES=n/a
PiperOrigin-RevId: 522214387

Author: cpovirk

android/guava-testlib/src/com/google/common/testing/IgnoreJRERequirement.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2019 The Guava Authors
+ *
+ * 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.common.testing;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+import java.lang.annotation.Target;
+
+/**
+ * Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
+ *
+ * <p>Each package's copy of this annotation needs to be listed in our {@code pom.xml}.
+ */
+@Target({METHOD, CONSTRUCTOR, TYPE})
+@interface IgnoreJRERequirement {}

android/guava-testlib/src/com/google/common/testing/NullPointerTester.java

@@ -34,14 +34,15 @@
 import com.google.common.reflect.TypeToken;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ConcurrentMap;
@@ -52,8 +53,8 @@
 /**
  * A test utility that verifies that your methods and constructors throw {@link
  * NullPointerException} or {@link UnsupportedOperationException} whenever null is passed to a
- * parameter that isn't annotated with an annotation with the simple name {@code Nullable}, {@code
- * CheckForNull}, {@code NullableType}, or {@code NullableDecl}.
+ * parameter whose declaration or type isn't annotated with an annotation with the simple name
+ * {@code Nullable}, {@code CheckForNull}, {@code NullableType}, or {@code NullableDecl}.
  *
  * <p>The tested methods and constructors are invoked -- each time with one parameter being null and
  * the rest not null -- and the test fails if no expected exception is thrown. {@code
@@ -495,8 +496,16 @@ static boolean isPrimitiveOrNullable(Parameter param) {
       ImmutableSet.of(
           "CheckForNull", "Nullable", "NullableDecl", "NullableType", "ParametricNullness");
 
-  static boolean isNullable(AnnotatedElement e) {
-    for (Annotation annotation : e.getAnnotations()) {
+  static boolean isNullable(Invokable<?, ?> invokable) {
+    return NULLNESS_ANNOTATION_READER.isNullable(invokable);
+  }
+
+  static boolean isNullable(Parameter param) {
+    return NULLNESS_ANNOTATION_READER.isNullable(param);
+  }
+
+  private static boolean containsNullable(Annotation[] annotations) {
+    for (Annotation annotation : annotations) {
       if (NULLABLE_ANNOTATION_SIMPLE_NAMES.contains(annotation.annotationType().getSimpleName())) {
         return true;
       }
@@ -567,4 +576,82 @@ public boolean isExpectedType(Throwable cause) {
 
     public abstract boolean isExpectedType(Throwable cause);
   }
+
+  private static boolean annotatedTypeExists() {
+    try {
+      Class.forName("java.lang.reflect.AnnotatedType");
+    } catch (ClassNotFoundException e) {
+      return false;
+    }
+    return true;
+  }
+
+  private static final NullnessAnnotationReader NULLNESS_ANNOTATION_READER =
+      annotatedTypeExists()
+          ? NullnessAnnotationReader.FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS
+          : NullnessAnnotationReader.FROM_DECLARATION_ANNOTATIONS_ONLY;
+
+  /**
+   * Looks for declaration nullness annotations and, if supported, type-use nullness annotations.
+   *
+   * <p>Under Android VMs, the methods for retrieving type-use annotations don't exist. This means
+   * that {@link NullPointerException} may misbehave under Android when used on classes that rely on
+   * type-use annotations.
+   *
+   * <p>Under j2objc, the necessary APIs exist, but some (perhaps all) return stub values, like
+   * empty arrays. Presumably {@link NullPointerException} could likewise misbehave under j2objc,
+   * but I don't know that anyone uses it there, anyway.
+   */
+  private enum NullnessAnnotationReader {
+    // Usages (which are unsafe only for Android) are guarded by the annotatedTypeExists() check.
+    @SuppressWarnings({"Java7ApiChecker", "AndroidApiChecker", "DoNotCall", "deprecation"})
+    FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS {
+      @Override
+      @IgnoreJRERequirement
+      boolean isNullable(Invokable<?, ?> invokable) {
+        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(invokable)
+            || containsNullable(invokable.getAnnotatedReturnType().getAnnotations());
+        // TODO(cpovirk): Should we also check isNullableTypeVariable?
+      }
+
+      @Override
+      @IgnoreJRERequirement
+      boolean isNullable(Parameter param) {
+        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(param)
+            || containsNullable(param.getAnnotatedType().getAnnotations())
+            || isNullableTypeVariable(param.getAnnotatedType().getType());
+      }
+
+      @IgnoreJRERequirement
+      boolean isNullableTypeVariable(Type type) {
+        if (!(type instanceof TypeVariable)) {
+          return false;
+        }
+        TypeVariable<?> typeVar = (TypeVariable<?>) type;
+        for (AnnotatedType bound : typeVar.getAnnotatedBounds()) {
+          // Until Java 15, the isNullableTypeVariable case here won't help:
+          // https://bugs.openjdk.java.net/browse/JDK-8202469
+          if (containsNullable(bound.getAnnotations()) || isNullableTypeVariable(bound.getType())) {
+            return true;
+          }
+        }
+        return false;
+      }
+    },
+    FROM_DECLARATION_ANNOTATIONS_ONLY {
+      @Override
+      boolean isNullable(Invokable<?, ?> invokable) {
+        return containsNullable(invokable.getAnnotations());
+      }
+
+      @Override
+      boolean isNullable(Parameter param) {
+        return containsNullable(param.getAnnotations());
+      }
+    };
+
+    abstract boolean isNullable(Invokable<?, ?> invokable);
+
+    abstract boolean isNullable(Parameter param);
+  }
 }

android/guava-tests/test/com/google/common/reflect/ParameterTest.java

@@ -29,6 +29,16 @@
 public class ParameterTest extends TestCase {
 
   public void testNulls() {
+    try {
+      Class.forName("java.lang.reflect.AnnotatedType");
+    } catch (ClassNotFoundException runningInAndroidVm) {
+      /*
+       * Parameter declares a method that returns AnnotatedType, which isn't available on Android.
+       * This would cause NullPointerTester, which calls Class.getDeclaredMethods, to throw
+       * NoClassDefFoundError.
+       */
+      return;
+    }
     for (Method method : ParameterTest.class.getDeclaredMethods()) {
       for (Parameter param : Invokable.from(method).getParameters()) {
         new NullPointerTester().testAllPublicInstanceMethods(param);

android/guava/src/com/google/common/reflect/IgnoreJRERequirement.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 The Guava Authors
+ *
+ * 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.common.reflect;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+import java.lang.annotation.Target;
+
+/**
+ * Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
+ *
+ * <p>Each package's copy of this annotation needs to be listed in our {@code pom.xml}.
+ */
+@Target({METHOD, CONSTRUCTOR, TYPE})
+@ElementTypesAreNonnullByDefault
+@interface IgnoreJRERequirement {}

android/guava/src/com/google/common/reflect/Invokable.java

@@ -19,9 +19,11 @@
 import com.google.common.annotations.Beta;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.DoNotCall;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Member;
@@ -272,12 +274,17 @@ public final TypeToken<? extends R> getReturnType() {
    * of a non-static inner class, unlike {@link Constructor#getParameterTypes}, the hidden {@code
    * this} parameter of the enclosing class is excluded from the returned parameters.
    */
+  @IgnoreJRERequirement
   public final ImmutableList<Parameter> getParameters() {
     Type[] parameterTypes = getGenericParameterTypes();
     Annotation[][] annotations = getParameterAnnotations();
+    @Nullable Object[] annotatedTypes =
+        ANNOTATED_TYPE_EXISTS ? getAnnotatedParameterTypes() : new Object[parameterTypes.length];
     ImmutableList.Builder<Parameter> builder = ImmutableList.builder();
     for (int i = 0; i < parameterTypes.length; i++) {
-      builder.add(new Parameter(this, i, TypeToken.of(parameterTypes[i]), annotations[i]));
+      builder.add(
+          new Parameter(
+              this, i, TypeToken.of(parameterTypes[i]), annotations[i], annotatedTypes[i]));
     }
     return builder.build();
   }
@@ -337,13 +344,32 @@ abstract Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[]
 
   abstract Type[] getGenericParameterTypes();
 
+  @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @IgnoreJRERequirement
+  abstract AnnotatedType[] getAnnotatedParameterTypes();
+
   /** This should never return a type that's not a subtype of Throwable. */
   abstract Type[] getGenericExceptionTypes();
 
   abstract Annotation[][] getParameterAnnotations();
 
   abstract Type getGenericReturnType();
 
+  /**
+   * Returns the {@link AnnotatedType} for the return type.
+   *
+   * <p>This method will fail if run under an Android VM.
+   *
+   * @since NEXT for guava-android (available since 14.0 in guava-jre)
+   * @deprecated This method does not work under Android VMs. It is safe to use from guava-jre, but
+   *     this copy in guava-android is not safe to use.
+   */
+  @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @DoNotCall("fails under Android VMs; do not use from guava-android")
+  @Deprecated
+  @IgnoreJRERequirement
+  public abstract AnnotatedType getAnnotatedReturnType();
+
   static class MethodInvokable<T> extends Invokable<T, Object> {
 
     final Method method;
@@ -370,6 +396,21 @@ Type[] getGenericParameterTypes() {
       return method.getGenericParameterTypes();
     }
 
+    @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+    @IgnoreJRERequirement
+    AnnotatedType[] getAnnotatedParameterTypes() {
+      return method.getAnnotatedParameterTypes();
+    }
+
+    @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker", "DoNotCall"})
+    @DoNotCall
+    @IgnoreJRERequirement
+    public AnnotatedType getAnnotatedReturnType() {
+      return method.getAnnotatedReturnType();
+    }
+
     @Override
     Type[] getGenericExceptionTypes() {
       return method.getGenericExceptionTypes();
@@ -447,6 +488,21 @@ Type[] getGenericParameterTypes() {
       return types;
     }
 
+    @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+    @IgnoreJRERequirement
+    AnnotatedType[] getAnnotatedParameterTypes() {
+      return constructor.getAnnotatedParameterTypes();
+    }
+
+    @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker", "DoNotCall"})
+    @DoNotCall
+    @IgnoreJRERequirement
+    public AnnotatedType getAnnotatedReturnType() {
+      return constructor.getAnnotatedReturnType();
+    }
+
     @Override
     Type[] getGenericExceptionTypes() {
       return constructor.getGenericExceptionTypes();
@@ -510,4 +566,15 @@ private boolean mayNeedHiddenThis() {
       }
     }
   }
+
+  private static final boolean ANNOTATED_TYPE_EXISTS = initAnnotatedTypeExists();
+
+  private static boolean initAnnotatedTypeExists() {
+    try {
+      Class.forName("java.lang.reflect.AnnotatedType");
+    } catch (ClassNotFoundException e) {
+      return false;
+    }
+    return true;
+  }
 }

android/guava/src/com/google/common/reflect/Parameter.java

@@ -15,12 +15,15 @@
 package com.google.common.reflect;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
 
 import com.google.common.annotations.Beta;
 import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.DoNotCall;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.AnnotatedType;
 import javax.annotation.CheckForNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -43,12 +46,26 @@ public final class Parameter implements AnnotatedElement {
   private final TypeToken<?> type;
   private final ImmutableList<Annotation> annotations;
 
+  /**
+   * An {@link AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
+   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
+   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the
+   * more specific return type as long as users are careful to guard calls to it with version checks
+   * or reflection: Android VMs ignore the types of elements that aren't used.
+   */
+  private final @Nullable Object annotatedType;
+
   Parameter(
-      Invokable<?, ?> declaration, int position, TypeToken<?> type, Annotation[] annotations) {
+      Invokable<?, ?> declaration,
+      int position,
+      TypeToken<?> type,
+      Annotation[] annotations,
+      @Nullable Object annotatedType) {
     this.declaration = declaration;
     this.position = position;
     this.type = type;
     this.annotations = ImmutableList.copyOf(annotations);
+    this.annotatedType = annotatedType;
   }
 
   /** Returns the type of the parameter. */
@@ -83,29 +100,34 @@ public Annotation[] getAnnotations() {
     return getDeclaredAnnotations();
   }
 
-  /** @since 18.0 */
-  // @Override on JDK8
+  /**
+   * @since 18.0
+   */
+  @Override
   public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
     return getDeclaredAnnotationsByType(annotationType);
   }
 
   /** @since 18.0 */
-  // @Override on JDK8
   @Override
   public Annotation[] getDeclaredAnnotations() {
     return annotations.toArray(new Annotation[0]);
   }
 
-  /** @since 18.0 */
-  // @Override on JDK8
+  /**
+   * @since 18.0
+   */
+  @Override
   @CheckForNull
   public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationType) {
     checkNotNull(annotationType);
     return FluentIterable.from(annotations).filter(annotationType).first().orNull();
   }
 
-  /** @since 18.0 */
-  // @Override on JDK8
+  /**
+   * @since 18.0
+   */
+  @Override
   public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationType) {
     @Nullable
     A[] result = FluentIterable.from(annotations).filter(annotationType).toArray(annotationType);
@@ -114,6 +136,23 @@ public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotati
     return cast;
   }
 
+  /**
+   * Returns the {@link AnnotatedType} of the parameter.
+   *
+   * <p>This method will fail if run under an Android VM.
+   *
+   * @since NEXT for guava-android (available since 25.1 in guava-jre)
+   * @deprecated This method does not work under Android VMs. It is safe to use from guava-jre, but
+   *     this copy in guava-android is not safe to use.
+   */
+  @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @Deprecated
+  @DoNotCall("fails under Android VMs; do not use from guava-android")
+  @IgnoreJRERequirement
+  public AnnotatedType getAnnotatedType() {
+    return requireNonNull((AnnotatedType) annotatedType);
+  }
+
   @Override
   public boolean equals(@CheckForNull Object obj) {
     if (obj instanceof Parameter) {

android/pom.xml

@@ -178,6 +178,7 @@
           <artifactId>animal-sniffer-maven-plugin</artifactId>
           <version>${animal.sniffer.version}</version>
           <configuration>
+            <annotations>com.google.common.reflect.IgnoreJRERequirement,com.google.common.testing.IgnoreJRERequirement</annotations>
             <checkTestClasses>true</checkTestClasses>
             <signature>
               <groupId>org.codehaus.mojo.signature</groupId>

guava-testlib/src/com/google/common/testing/IgnoreJRERequirement.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2019 The Guava Authors
+ *
+ * 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.common.testing;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+import java.lang.annotation.Target;
+
+/**
+ * Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
+ *
+ * <p>Each package's copy of this annotation needs to be listed in our {@code pom.xml}.
+ */
+@Target({METHOD, CONSTRUCTOR, TYPE})
+@interface IgnoreJRERequirement {}

guava-testlib/src/com/google/common/testing/NullPointerTester.java

@@ -46,7 +46,6 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ConcurrentMap;
-import java.util.function.Function;
 import junit.framework.Assert;
 import junit.framework.AssertionFailedError;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -498,30 +497,11 @@ static boolean isPrimitiveOrNullable(Parameter param) {
           "CheckForNull", "Nullable", "NullableDecl", "NullableType", "ParametricNullness");
 
   static boolean isNullable(Invokable<?, ?> invokable) {
-    return containsNullable(invokable.getAnnotatedReturnType().getAnnotations())
-        || containsNullable(invokable.getAnnotations());
+    return NULLNESS_ANNOTATION_READER.isNullable(invokable);
   }
 
   static boolean isNullable(Parameter param) {
-    return containsNullable(param.getAnnotatedType().getAnnotations())
-        || containsNullable(param.getAnnotations())
-        || isNullableTypeVariable(param.getAnnotatedType().getType());
-  }
-
-  private static boolean isNullableTypeVariable(Type type) {
-    if (!(type instanceof TypeVariable)) {
-      return false;
-    }
-    TypeVariable<?> var = (TypeVariable<?>) type;
-    AnnotatedType[] bounds = GET_ANNOTATED_BOUNDS.apply(var);
-    for (AnnotatedType bound : bounds) {
-      // Until Java 15, the isNullableTypeVariable case here won't help:
-      // https://bugs.openjdk.java.net/browse/JDK-8202469
-      if (containsNullable(bound.getAnnotations()) || isNullableTypeVariable(bound.getType())) {
-        return true;
-      }
-    }
-    return false;
+    return NULLNESS_ANNOTATION_READER.isNullable(param);
   }
 
   private static boolean containsNullable(Annotation[] annotations) {
@@ -533,27 +513,6 @@ private static boolean containsNullable(Annotation[] annotations) {
     return false;
   }
 
-  // This is currently required because of j2objc restrictions.
-  private static final Function<TypeVariable<?>, AnnotatedType[]> GET_ANNOTATED_BOUNDS =
-      initGetAnnotatedBounds();
-
-  private static Function<TypeVariable<?>, AnnotatedType[]> initGetAnnotatedBounds() {
-    AnnotatedType[] noBounds = new AnnotatedType[0];
-    Method getAnnotatedBounds;
-    try {
-      getAnnotatedBounds = TypeVariable.class.getMethod("getAnnotatedBounds");
-    } catch (ReflectiveOperationException e) {
-      return v -> noBounds;
-    }
-    return v -> {
-      try {
-        return (AnnotatedType[]) getAnnotatedBounds.invoke(v);
-      } catch (ReflectiveOperationException e) {
-        return noBounds;
-      }
-    };
-  }
-
   private boolean isIgnored(Member member) {
     return member.isSynthetic() || ignoredMembers.contains(member) || isEquals(member);
   }
@@ -617,4 +576,82 @@ public boolean isExpectedType(Throwable cause) {
 
     public abstract boolean isExpectedType(Throwable cause);
   }
+
+  private static boolean annotatedTypeExists() {
+    try {
+      Class.forName("java.lang.reflect.AnnotatedType");
+    } catch (ClassNotFoundException e) {
+      return false;
+    }
+    return true;
+  }
+
+  private static final NullnessAnnotationReader NULLNESS_ANNOTATION_READER =
+      annotatedTypeExists()
+          ? NullnessAnnotationReader.FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS
+          : NullnessAnnotationReader.FROM_DECLARATION_ANNOTATIONS_ONLY;
+
+  /**
+   * Looks for declaration nullness annotations and, if supported, type-use nullness annotations.
+   *
+   * <p>Under Android VMs, the methods for retrieving type-use annotations don't exist. This means
+   * that {@link NullPointerException} may misbehave under Android when used on classes that rely on
+   * type-use annotations.
+   *
+   * <p>Under j2objc, the necessary APIs exist, but some (perhaps all) return stub values, like
+   * empty arrays. Presumably {@link NullPointerException} could likewise misbehave under j2objc,
+   * but I don't know that anyone uses it there, anyway.
+   */
+  private enum NullnessAnnotationReader {
+    // Usages (which are unsafe only for Android) are guarded by the annotatedTypeExists() check.
+    @SuppressWarnings({"Java7ApiChecker", "AndroidApiChecker", "DoNotCall", "deprecation"})
+    FROM_DECLARATION_AND_TYPE_USE_ANNOTATIONS {
+      @Override
+      @IgnoreJRERequirement
+      boolean isNullable(Invokable<?, ?> invokable) {
+        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(invokable)
+            || containsNullable(invokable.getAnnotatedReturnType().getAnnotations());
+        // TODO(cpovirk): Should we also check isNullableTypeVariable?
+      }
+
+      @Override
+      @IgnoreJRERequirement
+      boolean isNullable(Parameter param) {
+        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(param)
+            || containsNullable(param.getAnnotatedType().getAnnotations())
+            || isNullableTypeVariable(param.getAnnotatedType().getType());
+      }
+
+      @IgnoreJRERequirement
+      boolean isNullableTypeVariable(Type type) {
+        if (!(type instanceof TypeVariable)) {
+          return false;
+        }
+        TypeVariable<?> typeVar = (TypeVariable<?>) type;
+        for (AnnotatedType bound : typeVar.getAnnotatedBounds()) {
+          // Until Java 15, the isNullableTypeVariable case here won't help:
+          // https://bugs.openjdk.java.net/browse/JDK-8202469
+          if (containsNullable(bound.getAnnotations()) || isNullableTypeVariable(bound.getType())) {
+            return true;
+          }
+        }
+        return false;
+      }
+    },
+    FROM_DECLARATION_ANNOTATIONS_ONLY {
+      @Override
+      boolean isNullable(Invokable<?, ?> invokable) {
+        return containsNullable(invokable.getAnnotations());
+      }
+
+      @Override
+      boolean isNullable(Parameter param) {
+        return containsNullable(param.getAnnotations());
+      }
+    };
+
+    abstract boolean isNullable(Invokable<?, ?> invokable);
+
+    abstract boolean isNullable(Parameter param);
+  }
 }

guava-tests/test/com/google/common/reflect/ParameterTest.java

@@ -29,6 +29,16 @@
 public class ParameterTest extends TestCase {
 
   public void testNulls() {
+    try {
+      Class.forName("java.lang.reflect.AnnotatedType");
+    } catch (ClassNotFoundException runningInAndroidVm) {
+      /*
+       * Parameter declares a method that returns AnnotatedType, which isn't available on Android.
+       * This would cause NullPointerTester, which calls Class.getDeclaredMethods, to throw
+       * NoClassDefFoundError.
+       */
+      return;
+    }
     for (Method method : ParameterTest.class.getDeclaredMethods()) {
       for (Parameter param : Invokable.from(method).getParameters()) {
         new NullPointerTester().testAllPublicInstanceMethods(param);

guava/src/com/google/common/reflect/IgnoreJRERequirement.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 The Guava Authors
+ *
+ * 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.common.reflect;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+
+import java.lang.annotation.Target;
+
+/**
+ * Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
+ *
+ * <p>Each package's copy of this annotation needs to be listed in our {@code pom.xml}.
+ */
+@Target({METHOD, CONSTRUCTOR, TYPE})
+@ElementTypesAreNonnullByDefault
+@interface IgnoreJRERequirement {}

guava/src/com/google/common/reflect/Invokable.java

@@ -273,10 +273,12 @@ public final TypeToken<? extends R> getReturnType() {
    * of a non-static inner class, unlike {@link Constructor#getParameterTypes}, the hidden {@code
    * this} parameter of the enclosing class is excluded from the returned parameters.
    */
+  @IgnoreJRERequirement
   public final ImmutableList<Parameter> getParameters() {
     Type[] parameterTypes = getGenericParameterTypes();
     Annotation[][] annotations = getParameterAnnotations();
-    AnnotatedType[] annotatedTypes = getAnnotatedParameterTypes();
+    @Nullable Object[] annotatedTypes =
+        ANNOTATED_TYPE_EXISTS ? getAnnotatedParameterTypes() : new Object[parameterTypes.length];
     ImmutableList.Builder<Parameter> builder = ImmutableList.builder();
     for (int i = 0; i < parameterTypes.length; i++) {
       builder.add(
@@ -341,6 +343,8 @@ abstract Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[]
 
   abstract Type[] getGenericParameterTypes();
 
+  @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @IgnoreJRERequirement
   abstract AnnotatedType[] getAnnotatedParameterTypes();
 
   /** This should never return a type that's not a subtype of Throwable. */
@@ -350,6 +354,15 @@ abstract Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[]
 
   abstract Type getGenericReturnType();
 
+  /**
+   * Returns the {@link AnnotatedType} for the return type.
+   *
+   * <p>This method will fail if run under an Android VM.
+   *
+   * @since 14.0 for guava-jre (available since 32.0 in guava-android)
+   */
+  @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @IgnoreJRERequirement
   public abstract AnnotatedType getAnnotatedReturnType();
 
   static class MethodInvokable<T> extends Invokable<T, Object> {
@@ -379,11 +392,15 @@ Type[] getGenericParameterTypes() {
     }
 
     @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+    @IgnoreJRERequirement
     AnnotatedType[] getAnnotatedParameterTypes() {
       return method.getAnnotatedParameterTypes();
     }
 
     @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker", "DoNotCall"})
+    @IgnoreJRERequirement
     public AnnotatedType getAnnotatedReturnType() {
       return method.getAnnotatedReturnType();
     }
@@ -466,11 +483,15 @@ Type[] getGenericParameterTypes() {
     }
 
     @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+    @IgnoreJRERequirement
     AnnotatedType[] getAnnotatedParameterTypes() {
       return constructor.getAnnotatedParameterTypes();
     }
 
     @Override
+    @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker", "DoNotCall"})
+    @IgnoreJRERequirement
     public AnnotatedType getAnnotatedReturnType() {
       return constructor.getAnnotatedReturnType();
     }
@@ -538,4 +559,15 @@ private boolean mayNeedHiddenThis() {
       }
     }
   }
+
+  private static final boolean ANNOTATED_TYPE_EXISTS = initAnnotatedTypeExists();
+
+  private static boolean initAnnotatedTypeExists() {
+    try {
+      Class.forName("java.lang.reflect.AnnotatedType");
+    } catch (ClassNotFoundException e) {
+      return false;
+    }
+    return true;
+  }
 }

guava/src/com/google/common/reflect/Parameter.java

@@ -15,6 +15,7 @@
 package com.google.common.reflect;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
 
 import com.google.common.annotations.Beta;
 import com.google.common.collect.FluentIterable;
@@ -43,14 +44,22 @@ public final class Parameter implements AnnotatedElement {
   private final int position;
   private final TypeToken<?> type;
   private final ImmutableList<Annotation> annotations;
-  private final AnnotatedType annotatedType;
+
+  /**
+   * An {@link AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
+   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
+   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the
+   * more specific return type as long as users are careful to guard calls to it with version checks
+   * or reflection: Android VMs ignore the types of elements that aren't used.
+   */
+  private final @Nullable Object annotatedType;
 
   Parameter(
       Invokable<?, ?> declaration,
       int position,
       TypeToken<?> type,
       Annotation[] annotations,
-      AnnotatedType annotatedType) {
+      @Nullable Object annotatedType) {
     this.declaration = declaration;
     this.position = position;
     this.type = type;
@@ -91,21 +100,18 @@ public Annotation[] getAnnotations() {
   }
 
   /** @since 18.0 */
-  // @Override on JDK8
   @Override
   public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
     return getDeclaredAnnotationsByType(annotationType);
   }
 
   /** @since 18.0 */
-  // @Override on JDK8
   @Override
   public Annotation[] getDeclaredAnnotations() {
     return annotations.toArray(new Annotation[0]);
   }
 
   /** @since 18.0 */
-  // @Override on JDK8
   @Override
   @CheckForNull
   public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationType) {
@@ -114,7 +120,6 @@ public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationType) {
   }
 
   /** @since 18.0 */
-  // @Override on JDK8
   @Override
   public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationType) {
     @Nullable
@@ -124,10 +129,17 @@ public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotati
     return cast;
   }
 
-  /** @since 25.1 */
-  // @Override on JDK8
+  /**
+   * Returns the {@link AnnotatedType} of the parameter.
+   *
+   * <p>This method will fail if run under an Android VM.
+   *
+   * @since 25.1 for guava-jre (available since 32.0 in guava-android)
+   */
+  @SuppressWarnings({"Java7ApiChecker", "AndroidJdkLibsChecker"})
+  @IgnoreJRERequirement
   public AnnotatedType getAnnotatedType() {
-    return annotatedType;
+    return requireNonNull((AnnotatedType) annotatedType);
   }
 
   @Override

pom.xml

@@ -179,6 +179,7 @@
           <artifactId>animal-sniffer-maven-plugin</artifactId>
           <version>${animal.sniffer.version}</version>
           <configuration>
+            <annotations>com.google.common.reflect.IgnoreJRERequirement,com.google.common.testing.IgnoreJRERequirement</annotations>
             <checkTestClasses>true</checkTestClasses>
             <signature>
               <groupId>org.codehaus.mojo.signature</groupId>