Use Type Use Annotations correctly when assigning null to non-null array component. (#267)

avenger2597 · web-flow · commit 876f635f670e · 2025-02-13T15:41:30.000-08:00
This PR adds Nulllable annotation at the component of an array in case when null is being assigned to it. This feature uses TypeUseAnnotations and is available only in Jspecify mode. We check for a specific error message from Nullaway checker - `ASSIGN_NULLABLE_TO_NONNULL_ARRAY` and based on this create Type Use annotation at the required index.
diff --git a/annotator-core/src/main/java/edu/ucr/cs/riple/core/checkers/nullaway/NullAway.java b/annotator-core/src/main/java/edu/ucr/cs/riple/core/checkers/nullaway/NullAway.java
@@ -25,6 +25,7 @@
 package edu.ucr.cs.riple.core.checkers.nullaway;
 
 import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import edu.ucr.cs.riple.core.Context;
 import edu.ucr.cs.riple.core.checkers.CheckerBaseClass;
@@ -134,7 +135,17 @@ private NullAwayError deserializeErrorFromTSVLine(ModuleInfo moduleInfo, String
     if (nonnullTarget == null) {
       annotations = Set.of();
     } else if (Utility.isTypeUseAnnotation(config.nullableAnnot)) {
-      annotations = Set.of(new AddTypeUseMarkerAnnotation(nonnullTarget, config.nullableAnnot));
+      if (errorType.equals(NullAwayError.ASSIGN_NULLABLE_TO_NONNULL_ARRAY)) {
+        // The error ASSIGN_NULLABLE_TO_NONNULL_ARRAY from NullAway triggers a fix on an array
+        // variable
+        // with [1, 0] indicating its component type.
+        annotations =
+            Set.of(
+                new AddTypeUseMarkerAnnotation(
+                    nonnullTarget, config.nullableAnnot, ImmutableList.of(ImmutableList.of(1, 0))));
+      } else {
+        annotations = Set.of(new AddTypeUseMarkerAnnotation(nonnullTarget, config.nullableAnnot));
+      }
     } else {
       annotations = Set.of(new AddMarkerAnnotation(nonnullTarget, config.nullableAnnot));
     }
diff --git a/annotator-core/src/main/java/edu/ucr/cs/riple/core/checkers/nullaway/NullAwayError.java b/annotator-core/src/main/java/edu/ucr/cs/riple/core/checkers/nullaway/NullAwayError.java
@@ -41,6 +41,12 @@ public class NullAwayError extends Error {
   /** Error type for field initialization errors from NullAway in {@code String}. */
   public static final String FIELD_INITIALIZER_ERROR = "FIELD_NO_INIT";
 
+  /**
+   * Error type for assigning nullable values to non-nullable arrays from NullAway in {@code
+   * String}.
+   */
+  public static final String ASSIGN_NULLABLE_TO_NONNULL_ARRAY = "ASSIGN_NULLABLE_TO_NONNULL_ARRAY";
+
   public NullAwayError(
       String messageType,
       String message,
diff --git a/annotator-core/src/test/java/edu/ucr/cs/riple/core/CoreTest.java b/annotator-core/src/test/java/edu/ucr/cs/riple/core/CoreTest.java
@@ -27,6 +27,7 @@
 import static com.google.common.collect.Sets.newHashSet;
 import static java.util.Collections.singleton;
 
+import com.google.common.collect.ImmutableList;
 import edu.ucr.cs.riple.core.tools.TReport;
 import edu.ucr.cs.riple.injector.location.OnField;
 import edu.ucr.cs.riple.injector.location.OnMethod;
@@ -572,4 +573,28 @@ public void nonnullTypeUseAnnotationOnFormalParameterAcknowledgmentTest() {
     // No annotation should be added even though it can reduce the number of errors.
     Assert.assertEquals(coreTestHelper.getLog().getInjectedAnnotations().size(), 0);
   }
+
+  @Test
+  public void assignNullableToNonnullArrayComponentTypeTest() {
+    coreTestHelper
+        .onTarget()
+        .withSourceLines(
+            "Main.java",
+            "package test;",
+            "public class Main {",
+            "   Object[] arr = new Object[1];",
+            "   void run() {",
+            "     arr[0] = null;",
+            "   }",
+            "}")
+        .withExpectedReports(
+            new TReport(
+                new OnField("Main.java", "test.Main", Set.of("arr")),
+                ImmutableList.of(ImmutableList.of(1, 0)),
+                -1))
+        .disableBailOut()
+        .checkExpectedOutput("assignNullableToNonnullArrayComponentTypeTest/expected")
+        .enableJSpecifyMode()
+        .start();
+  }
 }
diff --git a/annotator-core/src/test/java/edu/ucr/cs/riple/core/tools/CoreTestHelper.java b/annotator-core/src/test/java/edu/ucr/cs/riple/core/tools/CoreTestHelper.java
@@ -109,12 +109,19 @@ public class CoreTestHelper {
 
   private ParserConfiguration.LanguageLevel languageLevel;
 
+  /**
+   * JSpecify mode activation. Deactivated by default. If activated, the test will enable {<a
+   * href="https://jspecify.dev">JSpecify</a>} mode on NullAway.
+   */
+  private boolean jSpecifyModeEnabled;
+
   public CoreTestHelper(Path projectPath, Path outDirPath) {
     this.projectPath = projectPath;
     this.outDirPath = outDirPath;
     this.expectedReports = new HashSet<>();
     this.projectBuilder = new ProjectBuilder(this, projectPath);
     this.languageLevel = ParserConfiguration.LanguageLevel.JAVA_17;
+    this.jSpecifyModeEnabled = false;
   }
 
   public Module onTarget() {
@@ -241,6 +248,16 @@ public CoreTestHelper withLanguageLevel(ParserConfiguration.LanguageLevel langua
     return this;
   }
 
+  /**
+   * Enables JSpecify mode.
+   *
+   * @return This instance of {@link CoreTestHelper}.
+   */
+  public CoreTestHelper enableJSpecifyMode() {
+    this.jSpecifyModeEnabled = true;
+    return this;
+  }
+
   /** Starts the test process. */
   public void start() {
     Path configPath = outDirPath.resolve("config.json");
@@ -430,7 +447,9 @@ public void makeAnnotatorConfigFile(Path configPath) {
                         outDirPath.resolve(name + "-scanner.xml")))
             .collect(Collectors.toList());
     builder.checker = NullAway.NAME;
-    builder.nullableAnnotation = "javax.annotation.Nullable";
+    // Set annotation name based on JSpecify mode activation.
+    builder.nullableAnnotation =
+        jSpecifyModeEnabled ? "org.jspecify.annotations.Nullable" : "javax.annotation.Nullable";
     // In tests, we use NullAway @Initializer annotation.
     builder.initializerAnnotation = "com.uber.nullaway.annotations.Initializer";
     builder.outputDir = outDirPath.toString();
@@ -453,17 +472,19 @@ public void makeAnnotatorConfigFile(Path configPath) {
         !getEnvironmentVariable("ANNOTATOR_TEST_DISABLE_PARALLEL_PROCESSING");
     if (downstreamDependencyAnalysisActivated) {
       builder.buildCommand =
-          projectBuilder.computeTargetBuildCommandWithLibraryModelLoaderDependency(this.outDirPath);
+          projectBuilder.computeTargetBuildCommandWithLibraryModelLoaderDependency(
+              this.outDirPath, jSpecifyModeEnabled);
       builder.downstreamBuildCommand =
           projectBuilder.computeDownstreamDependencyBuildCommandWithLibraryModelLoaderDependency(
-              this.outDirPath);
+              this.outDirPath, jSpecifyModeEnabled);
       builder.nullawayLibraryModelLoaderPath =
           Utility.getPathToLibraryModel(outDirPath)
               .resolve(
                   Paths.get(
                       "src", "main", "resources", "edu", "ucr", "cs", "riple", "librarymodel"));
     } else {
-      builder.buildCommand = projectBuilder.computeTargetBuildCommand(this.outDirPath);
+      builder.buildCommand =
+          projectBuilder.computeTargetBuildCommand(this.outDirPath, jSpecifyModeEnabled);
     }
     builder.write(configPath);
   }
diff --git a/annotator-core/src/test/java/edu/ucr/cs/riple/core/tools/ProjectBuilder.java b/annotator-core/src/test/java/edu/ucr/cs/riple/core/tools/ProjectBuilder.java
@@ -104,17 +104,19 @@ CoreTestHelper exitProjectConstruction() {
    * which will be passed through gradle command line arguments.
    *
    * @param outDirPath Path to serialization output directory,
+   * @param jSpecifyModeEnabled Flag to enable jSpecify mode when running NullAway.
    * @return The command to build the project including the command line arguments, this command can
    *     * be executed from any directory.
    */
-  public String computeTargetBuildCommand(Path outDirPath) {
+  public String computeTargetBuildCommand(Path outDirPath, boolean jSpecifyModeEnabled) {
     return String.format(
-        "%s && ./gradlew %s %s -Plibrary-model-loader-path=%s --rerun-tasks",
+        "%s && ./gradlew %s %s -Plibrary-model-loader-path=%s -Pjspecify=%s --rerun-tasks",
         Utility.changeDirCommand(pathToProject),
         computeCompileGradleCommandForModules(modules.subList(0, 1)),
         String.join(" ", Utility.computeConfigPathsWithGradleArguments(outDirPath, modules)),
         Utility.getPathToLibraryModel(outDirPath)
-            .resolve(Paths.get("build", "libs", "librarymodel.jar")));
+            .resolve(Paths.get("build", "libs", "librarymodel.jar")),
+        jSpecifyModeEnabled);
   }
 
   /**
@@ -124,18 +126,21 @@ public String computeTargetBuildCommand(Path outDirPath) {
    * line arguments.
    *
    * @param outDirPath Path to serialization output directory,
+   * @param jSpecifyModeEnabled Flag to enable jSpecify mode when running NullAway.
    * @return The command to build the project including the command line arguments, this command can
    *     * be executed from any directory.
    */
-  public String computeTargetBuildCommandWithLibraryModelLoaderDependency(Path outDirPath) {
+  public String computeTargetBuildCommandWithLibraryModelLoaderDependency(
+      Path outDirPath, boolean jSpecifyModeEnabled) {
     return String.format(
-        "%s && ./gradlew library-model-loader:jar --rerun-tasks && %s && ./gradlew %s %s -Plibrary-model-loader-path=%s --rerun-tasks",
+        "%s && ./gradlew library-model-loader:jar --rerun-tasks && %s && ./gradlew %s %s -Plibrary-model-loader-path=%s -Pjspecify=%s --rerun-tasks",
         Utility.changeDirCommand(outDirPath.resolve("Annotator")),
         Utility.changeDirCommand(pathToProject),
         computeCompileGradleCommandForModules(modules.subList(0, 1)),
         String.join(" ", Utility.computeConfigPathsWithGradleArguments(outDirPath, modules)),
         Utility.getPathToLibraryModel(outDirPath)
-            .resolve(Paths.get("build", "libs", "librarymodel.jar")));
+            .resolve(Paths.get("build", "libs", "librarymodel.jar")),
+        jSpecifyModeEnabled);
   }
 
   /**
@@ -145,19 +150,21 @@ public String computeTargetBuildCommandWithLibraryModelLoaderDependency(Path out
    * line arguments.
    *
    * @param outDirPath Path to serialization output directory,
+   * @param jSpecifyModeEnabled Flag to enable jSpecify mode when running NullAway.
    * @return The command to build the project including the command line arguments, this command can
    *     * be executed from any directory.
    */
   public String computeDownstreamDependencyBuildCommandWithLibraryModelLoaderDependency(
-      Path outDirPath) {
+      Path outDirPath, boolean jSpecifyModeEnabled) {
     return String.format(
-        "%s && ./gradlew library-model-loader:jar --rerun-tasks && %s && ./gradlew %s %s -Plibrary-model-loader-path=%s --rerun-tasks",
+        "%s && ./gradlew library-model-loader:jar --rerun-tasks && %s && ./gradlew %s %s -Plibrary-model-loader-path=%s -Pjspecify=%s --rerun-tasks",
         Utility.changeDirCommand(outDirPath.resolve("Annotator")),
         Utility.changeDirCommand(pathToProject),
         computeCompileGradleCommandForModules(modules.subList(1, modules.size())),
         String.join(" ", Utility.computeConfigPathsWithGradleArguments(outDirPath, modules)),
         Utility.getPathToLibraryModel(outDirPath)
-            .resolve(Paths.get("build", "libs", "librarymodel.jar")));
+            .resolve(Paths.get("build", "libs", "librarymodel.jar")),
+        jSpecifyModeEnabled);
   }
 
   /**
diff --git a/annotator-core/src/test/java/edu/ucr/cs/riple/core/tools/TReport.java b/annotator-core/src/test/java/edu/ucr/cs/riple/core/tools/TReport.java
@@ -24,11 +24,13 @@
 
 package edu.ucr.cs.riple.core.tools;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import edu.ucr.cs.riple.core.Config;
 import edu.ucr.cs.riple.core.Report;
 import edu.ucr.cs.riple.core.registries.index.Fix;
 import edu.ucr.cs.riple.injector.changes.AddMarkerAnnotation;
+import edu.ucr.cs.riple.injector.changes.AddTypeUseMarkerAnnotation;
 import edu.ucr.cs.riple.injector.location.Location;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -56,6 +58,13 @@ public TReport(Location root, int effect, Tag tag) {
     }
   }
 
+  public TReport(Location root, ImmutableList<ImmutableList<Integer>> index, int effect) {
+    super(
+        new Fix(new AddTypeUseMarkerAnnotation(root, "org.jspecify.annotations.Nullable", index)),
+        effect);
+    this.expectedValue = effect;
+  }
+
   public TReport(
       Location root,
       int effect,
diff --git a/annotator-core/src/test/resources/assignNullableToNonnullArrayComponentTypeTest/expected/Target/src/main/java/test/Main.java b/annotator-core/src/test/resources/assignNullableToNonnullArrayComponentTypeTest/expected/Target/src/main/java/test/Main.java
@@ -0,0 +1,8 @@
+package test;
+import org.jspecify.annotations.Nullable;
+public class Main {
+   @Nullable Object[] arr = new Object[1];
+   void run() {
+     arr[0] = null;
+   }
+}
diff --git a/annotator-core/src/test/resources/templates/java-17/build.gradle b/annotator-core/src/test/resources/templates/java-17/build.gradle
@@ -73,6 +73,7 @@ subprojects {
                 option("NullAway:SerializeFixMetadata", "true")
                 option("NullAway:FixSerializationConfigPath", project.getProperty(project.name + "-nullaway-config-path"))
                 option("NullAway:AcknowledgeLibraryModelsOfAnnotatedCode", "true")
+                option("NullAway:JSpecifyMode", project.getProperty("jspecify"))
                 option("AnnotatorScanner:ConfigPath", project.getProperty(project.name + "-scanner-config-path"))
             }
         }
diff --git a/annotator-core/src/test/resources/templates/lombok/build.gradle b/annotator-core/src/test/resources/templates/lombok/build.gradle
@@ -75,6 +75,7 @@ subprojects {
                 option("NullAway:SerializeFixMetadata", "true")
                 option("NullAway:FixSerializationConfigPath", project.getProperty(project.name + "-nullaway-config-path"))
                 option("NullAway:AcknowledgeLibraryModelsOfAnnotatedCode", "true")
+                option("NullAway:JSpecifyMode", project.getProperty("jspecify"))
                 option("AnnotatorScanner:ConfigPath", project.getProperty(project.name + "-scanner-config-path"))
             }
         }
diff --git a/annotator-core/src/test/resources/templates/nullable-multi-modular/build.gradle b/annotator-core/src/test/resources/templates/nullable-multi-modular/build.gradle
@@ -73,6 +73,7 @@ subprojects {
                 option("NullAway:SerializeFixMetadata", "true")
                 option("NullAway:FixSerializationConfigPath", project.getProperty(project.name + "-nullaway-config-path"))
                 option("NullAway:AcknowledgeLibraryModelsOfAnnotatedCode", "true")
+                option("NullAway:JSpecifyMode", project.getProperty("jspecify"))
                 option("AnnotatorScanner:ConfigPath", project.getProperty(project.name + "-scanner-config-path"))
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,7 @@ subprojects {`
`73`	`73`	`option("NullAway:SerializeFixMetadata", "true")`
`74`	`74`	`option("NullAway:FixSerializationConfigPath", project.getProperty(project.name + "-nullaway-config-path"))`
`75`	`75`	`option("NullAway:AcknowledgeLibraryModelsOfAnnotatedCode", "true")`
	`76`	`+ option("NullAway:JSpecifyMode", project.getProperty("jspecify"))`
`76`	`77`	`option("AnnotatorScanner:ConfigPath", project.getProperty(project.name + "-scanner-config-path"))`
`77`	`78`	`}`
`78`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,7 @@ subprojects {`
`75`	`75`	`option("NullAway:SerializeFixMetadata", "true")`
`76`	`76`	`option("NullAway:FixSerializationConfigPath", project.getProperty(project.name + "-nullaway-config-path"))`
`77`	`77`	`option("NullAway:AcknowledgeLibraryModelsOfAnnotatedCode", "true")`
	`78`	`+ option("NullAway:JSpecifyMode", project.getProperty("jspecify"))`
`78`	`79`	`option("AnnotatorScanner:ConfigPath", project.getProperty(project.name + "-scanner-config-path"))`
`79`	`80`	`}`
`80`	`81`	`}`