JSpecify: Modify Array Type Use Annotation Syntax

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

@@ -1962,7 +1962,8 @@ private SetMultimap<MethodTree, Symbol> checkConstructorInitialization(
   }
 
   private boolean symbolHasExternalInitAnnotation(Symbol symbol) {
-    return StreamSupport.stream(NullabilityUtil.getAllAnnotations(symbol).spliterator(), false)
+    return StreamSupport.stream(
+            NullabilityUtil.getAllAnnotations(symbol, config).spliterator(), false)
         .map((anno) -> anno.getAnnotationType().toString())
         .anyMatch(config::isExternalInitClassAnnotation);
   }
@@ -2219,7 +2220,7 @@ private boolean isInitializerMethod(VisitorState state, Symbol.MethodSymbol symb
   }
 
   private boolean skipDueToFieldAnnotation(Symbol fieldSymbol) {
-    return NullabilityUtil.getAllAnnotations(fieldSymbol)
+    return NullabilityUtil.getAllAnnotations(fieldSymbol, config)
         .map(anno -> anno.getAnnotationType().toString())
         .anyMatch(config::isExcludedFieldAnnotation);
   }

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

@@ -180,9 +180,9 @@ public static TreePath findEnclosingMethodOrLambdaOrInitializer(TreePath path) {
    * @param symbol the symbol
    * @return all annotations on the symbol and on the type of the symbol
    */
-  public static Stream<? extends AnnotationMirror> getAllAnnotations(Symbol symbol) {
+  public static Stream<? extends AnnotationMirror> getAllAnnotations(Symbol symbol, Config config) {
     // for methods, we care about annotations on the return type, not on the method type itself
-    Stream<? extends AnnotationMirror> typeUseAnnotations = getTypeUseAnnotations(symbol);
+    Stream<? extends AnnotationMirror> typeUseAnnotations = getTypeUseAnnotations(symbol, config);
     return Stream.concat(symbol.getAnnotationMirrors().stream(), typeUseAnnotations);
   }
 
@@ -277,27 +277,40 @@ public static Stream<? extends AnnotationMirror> getAllAnnotationsForParameter(
    * Gets the type use annotations on a symbol, ignoring annotations on components of the type (type
    * arguments, wildcards, etc.)
    */
-  private static Stream<? extends AnnotationMirror> getTypeUseAnnotations(Symbol symbol) {
+  private static Stream<? extends AnnotationMirror> getTypeUseAnnotations(
+      Symbol symbol, Config config) {
     Stream<Attribute.TypeCompound> rawTypeAttributes = symbol.getRawTypeAttributes().stream();
     if (symbol instanceof Symbol.MethodSymbol) {
       // for methods, we want annotations on the return type
       return rawTypeAttributes.filter(
-          (t) -> t.position.type.equals(TargetType.METHOD_RETURN) && isDirectTypeUseAnnotation(t));
+          (t) ->
+              t.position.type.equals(TargetType.METHOD_RETURN)
+                  && isDirectTypeUseAnnotation(t, config));
     } else {
       // filter for annotations directly on the type
-      return rawTypeAttributes.filter(NullabilityUtil::isDirectTypeUseAnnotation);
+      return rawTypeAttributes.filter(t -> NullabilityUtil.isDirectTypeUseAnnotation(t, config));
     }
   }
 
-  private static boolean isDirectTypeUseAnnotation(Attribute.TypeCompound t) {
+  /**
+   * Should a type-use annotation be treated as applying directly to the top-level type?
+   *
+   * @param t the annotation and its position in the type
+   * @param config NullAway configuration
+   * @return {@code true} if the annotation should be treated as applying directly to the top-level
+   *     type, false otherwise
+   */
+  private static boolean isDirectTypeUseAnnotation(Attribute.TypeCompound t, Config config) {
     // location is a list of TypePathEntry objects, indicating whether the annotation is
     // on an array, inner type, wildcard, or type argument. If it's empty, then the
     // annotation is directly on the type.
     // We care about both annotations directly on the outer type and also those directly
     // on an inner type or array dimension, but wish to discard annotations on wildcards,
     // or type arguments.
-    // For arrays, we treat annotations on the outer type and on any dimension of the array
-    // as applying to the nullability of the array itself, not the elements.
+    // For arrays, outside JSpecify mode, we treat annotations on the outer type and on any
+    // dimension of the array as applying to the nullability of the array itself, not the elements.
+    // In JSpecify mode, annotations on array dimensions are *not* treated as applying to the
+    // top-level type, consistent with the JSpecify spec.
     // We don't allow mixing of inner types and array dimensions in the same location
     // (i.e. `Foo.@Nullable Bar []` is meaningless).
     // These aren't correct semantics for type use annotations, but a series of hacky
@@ -313,6 +326,12 @@ private static boolean isDirectTypeUseAnnotation(Attribute.TypeCompound t) {
           locationHasInnerTypes = true;
           break;
         case ARRAY:
+          // Currently we are ignoring @Nullable annotations on type in JSpecify mode.
+          // Eventually, this should return true, and array access should be handled
+          // elsewhere.
+          if (config.isJSpecifyMode()) {
+            return false;
+          }
           locationHasArray = true;
           break;
         default:

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

@@ -192,7 +192,7 @@ private static boolean isNonNullAnnotation(String annotName, Config config) {
    * Config)}
    */
   public static boolean hasNonNullAnnotation(Symbol symbol, Config config) {
-    return hasNonNullAnnotation(NullabilityUtil.getAllAnnotations(symbol), config);
+    return hasNonNullAnnotation(NullabilityUtil.getAllAnnotations(symbol, config), config);
   }
 
   /**
@@ -203,7 +203,7 @@ public static boolean hasNonNullAnnotation(Symbol symbol, Config config) {
    * Config)}
    */
   public static boolean hasNullableAnnotation(Symbol symbol, Config config) {
-    return hasNullableAnnotation(NullabilityUtil.getAllAnnotations(symbol), config);
+    return hasNullableAnnotation(NullabilityUtil.getAllAnnotations(symbol, config), config);
   }
 
   /**

nullaway/src/test/java/com/uber/nullaway/NullAwayJSpecifyArrayTests.java

@@ -0,0 +1,91 @@
+package com.uber.nullaway;
+
+import com.google.errorprone.CompilationTestHelper;
+import java.util.Arrays;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class NullAwayJSpecifyArrayTests extends NullAwayTestsBase {
+
+  @Test
+  public void ArrayTypeAnnotationDereference() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  static @Nullable Integer [] fizz = {1};",
+            "  static void foo() {",
+            "  // OK: @Nullable annotations on type are ignored currently.",
+            "  // however, this should report an error eventually.",
+            "  int bar = fizz.length;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void ArrayTypeAnnotationAssignment() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  Object foo = new Object();",
+            "  void m( @Nullable Integer [] bar) {",
+            "  // OK: @Nullable annotations on type are ignored currently.",
+            "  // however, this should report an error eventually.",
+            "  foo = bar;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void ArrayElementAnnotationDereference() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  static String @Nullable [] fizz = {\"1\"};",
+            "  static void foo() {",
+            "    // This currently reports an error since fizz is @Nullable,",
+            "    // but it should eventually report due to fizz[0] being @Nullable",
+            "    // BUG: Diagnostic contains: dereferenced expression fizz is @Nullable",
+            "    int bar = fizz[0].length();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Ignore("We do not support annotations on array elements currently")
+  @Test
+  public void ArrayElementAnnotationAssignment() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  Object fizz = new Object();",
+            "  Object bar = new Object();",
+            "  void m( Integer @Nullable [] foo) {",
+            "    // BUG: assigning @Nullable expression to @NonNull field",
+            "    fizz = foo[0];",
+            "    // OK: valid assignment since only elements can be null",
+            "    bar = foo;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  private CompilationTestHelper makeHelper() {
+    return makeTestHelperWithArgs(
+        Arrays.asList(
+            "-XepOpt:NullAway:AnnotatedPackages=com.uber", "-XepOpt:NullAway:JSpecifyMode=true"));
+  }
+}