JSpecify: initial checks for generic type compatibility at assignments

nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java

@@ -31,9 +31,9 @@ public final class GenericsChecks {
 
   private static final Supplier<Type> NULLABLE_TYPE_SUPPLIER =
       Suppliers.typeFromString(NULLABLE_NAME);
-  VisitorState state;
-  Config config;
-  NullAway analysis;
+  private VisitorState state;
+  private Config config;
+  private NullAway analysis;
 
   public GenericsChecks(VisitorState state, Config config, NullAway analysis) {
     this.state = state;
@@ -172,11 +172,9 @@ public void checkTypeParameterNullnessForAssignability(Tree tree) {
         // no explicit type parameters
         return;
       }
-      rhsType =
-          typeWithPreservedAnnotations(
-              (ParameterizedTypeTree) ((NewClassTree) rhsTree).getIdentifier());
+      rhsType = typeWithPreservedAnnotations(paramTypedTree);
     }
-    if (lhsType != null && rhsType != null) {
+    if (lhsType instanceof Type.ClassType && rhsType instanceof Type.ClassType) {
       compareNullabilityAnnotations((Type.ClassType) lhsType, (Type.ClassType) rhsType, tree);
     }
   }
@@ -199,26 +197,40 @@ private void compareNullabilityAnnotations(
     // The base type of rhsType may be a subtype of lhsType's base type.  In such cases, we must
     // compare lhsType against the supertype of rhsType with a matching base type.
     rhsType = (Type.ClassType) types.asSuper(rhsType, lhsType.tsym);
+    // This is impossible, considering the fact that standard Java subtyping succeeds before running
+    // NullAway
     if (rhsType == null) {
-      throw new RuntimeException("did not find supertype of " + rhsType + " matching " + lhsType);
+      throw new RuntimeException("Did not find supertype of " + rhsType + " matching " + lhsType);
     }
     List<Type> lhsTypeArguments = lhsType.getTypeArguments();
     List<Type> rhsTypeArguments = rhsType.getTypeArguments();
+    // This is impossible, considering the fact that standard Java subtyping succeeds before running
+    // NullAway
     if (lhsTypeArguments.size() != rhsTypeArguments.size()) {
       throw new RuntimeException(
           "number of types arguments in " + rhsType + " does not match " + lhsType);
     }
     for (int i = 0; i < lhsTypeArguments.size(); i++) {
       Type lhsTypeArgument = lhsTypeArguments.get(i);
       Type rhsTypeArgument = rhsTypeArguments.get(i);
-      com.sun.tools.javac.util.List<Attribute.TypeCompound> annotationMirrorsLHS =
-          lhsTypeArgument.getAnnotationMirrors();
-      com.sun.tools.javac.util.List<Attribute.TypeCompound> annotationMirrorsRHS =
-          rhsTypeArgument.getAnnotationMirrors();
-      boolean isLHSNullableAnnotated =
-          Nullness.hasNullableAnnotation(annotationMirrorsLHS.stream(), config);
-      boolean isRHSNullableAnnotated =
-          Nullness.hasNullableAnnotation(annotationMirrorsRHS.stream(), config);
+      boolean isLHSNullableAnnotated = false;
+      List<Attribute.TypeCompound> lhsAnnotations = lhsTypeArgument.getAnnotationMirrors();
+      // To ensure that we are checking only jspecify nullable annotations
+      for (Attribute.TypeCompound annotation : lhsAnnotations) {
+        if (annotation.getAnnotationType().toString().equals(NULLABLE_NAME)) {
+          isLHSNullableAnnotated = true;
+          break;
+        }
+      }
+      boolean isRHSNullableAnnotated = false;
+      List<Attribute.TypeCompound> rhsAnnotations = rhsTypeArgument.getAnnotationMirrors();
+      // To ensure that we are checking only jspecify nullable annotations
+      for (Attribute.TypeCompound annotation : rhsAnnotations) {
+        if (annotation.getAnnotationType().toString().equals(NULLABLE_NAME)) {
+          isRHSNullableAnnotated = true;
+          break;
+        }
+      }
       if (isLHSNullableAnnotated != isRHSNullableAnnotated) {
         reportInvalidAssignmentInstantiationError(tree, lhsType, rhsType, state, analysis);
         return;
@@ -232,6 +244,10 @@ private void compareNullabilityAnnotations(
   }
 
   /**
+   * For the Parameterized typed trees ASTHelpers.getType(tree) does not return a Type with
+   * preserved annotations. This method takes a Parameterized typed tree as an input and returns the
+   * Type of the tree with the annotations.
+   *
    * @param tree A parameterized typed tree for which we need class type with preserved annotations.
    * @return A Type with preserved annotations.
    */

nullaway/src/main/java/com/uber/nullaway/NullAway.java

@@ -264,6 +264,7 @@ private enum NullMarking {
    * <p>TODO remove this once NullAway requires JDK 11
    */
   @Nullable private final Class<?> moduleElementClass;
+
   /**
    * Error Prone requires us to have an empty constructor for each Plugin, in addition to the
    * constructor taking an ErrorProneFlags object. This constructor should not be used anywhere