Add @NullUnmarked on classes

annotator-core/build.gradle

@@ -50,7 +50,7 @@ dependencies {
 }
 
 // Should be the latest supporting version of NullAway.
-def NULLAWAY_TEST = "0.10.6"
+def NULLAWAY_TEST = "0.10.8"
 
 tasks.test.dependsOn(':annotator-scanner:publishToMavenLocal')
 tasks.test.dependsOn(':qual:publishToMavenLocal')

annotator-core/src/main/java/edu/ucr/cs/riple/core/Annotator.java

@@ -262,6 +262,21 @@ private void forceResolveRemainingErrors() {
             .filter(Objects::nonNull)
             .map(node -> new AddMarkerAnnotation(node.location, config.nullUnMarkedAnnotation))
             .collect(Collectors.toSet());
+
+    // For errors within static initialization blocks, add a @NullUnmarked annotation on the
+    // enclosing class
+    nullUnMarkedAnnotations.addAll(
+        remainingErrors.stream()
+            .filter(
+                error ->
+                    error.getRegion().isOnInitializationBlock()
+                        && !error.getRegion().isInAnonymousClass())
+            .map(
+                error ->
+                    new AddMarkerAnnotation(
+                        fieldDeclarationStore.getLocationOnClass(error.getRegion().clazz),
+                        config.nullUnMarkedAnnotation))
+            .collect(Collectors.toSet()));
     injector.injectAnnotations(nullUnMarkedAnnotations);
     // Update log.
     config.log.updateInjectedAnnotations(nullUnMarkedAnnotations);
@@ -316,5 +331,21 @@ private void forceResolveRemainingErrors() {
     injector.injectAnnotations(initializationSuppressWarningsAnnotations);
     // Update log.
     config.log.updateInjectedAnnotations(initializationSuppressWarningsAnnotations);
+    // Collect @NullUnmarked annotations on classes for any remaining error.
+    Utility.buildTarget(config);
+    remainingErrors =
+        Utility.readErrorsFromOutputDirectory(config, config.target, fieldDeclarationStore);
+    nullUnMarkedAnnotations =
+        remainingErrors.stream()
+            .filter(error -> !error.getRegion().isInAnonymousClass())
+            .map(
+                error ->
+                    new AddMarkerAnnotation(
+                        fieldDeclarationStore.getLocationOnClass(error.getRegion().clazz),
+                        config.nullUnMarkedAnnotation))
+            .collect(Collectors.toSet());
+    injector.injectAnnotations(nullUnMarkedAnnotations);
+    // Update log.
+    config.log.updateInjectedAnnotations(nullUnMarkedAnnotations);
   }
 }

annotator-core/src/main/java/edu/ucr/cs/riple/core/metadata/field/FieldDeclarationStore.java

@@ -13,6 +13,7 @@
 import edu.ucr.cs.riple.core.metadata.MetaData;
 import edu.ucr.cs.riple.injector.Helper;
 import edu.ucr.cs.riple.injector.exceptions.TargetClassNotFound;
+import edu.ucr.cs.riple.injector.location.OnClass;
 import edu.ucr.cs.riple.injector.location.OnField;
 import edu.ucr.cs.riple.scanner.AnnotatorScanner;
 import java.io.FileNotFoundException;
@@ -90,7 +91,10 @@ protected FieldDeclarationInfo addNodeByLine(String[] values) {
                             .map(NodeWithSimpleName::getNameAsString)
                             .collect(ImmutableSet.toImmutableSet()));
                   }));
-      return info.isEmpty() ? null : info;
+      // We still want to keep the information about the class even if it has no field declarations,
+      // so we can retrieve tha path to the file from the given class flat name. This information is
+      // used in adding suppression annotations on class level.
+      return info;
     } catch (FileNotFoundException e) {
       return null;
     } catch (IOException e) {
@@ -136,4 +140,22 @@ public OnField getLocationOnField(String clazz, String field) {
     }
     return new OnField(candidate.pathToSourceFile, candidate.clazz, fieldNames);
   }
+
+  /**
+   * Creates a {@link edu.ucr.cs.riple.injector.location.OnClass} instance targeting the passed
+   * classes flat name.
+   *
+   * @param clazz Enclosing class of the field.
+   * @return {@link edu.ucr.cs.riple.injector.location.OnClass} instance targeting the passed
+   *     classes flat name.
+   */
+  public OnClass getLocationOnClass(String clazz) {
+    FieldDeclarationInfo candidate =
+        findNodeWithHashHint(node -> node.clazz.equals(clazz), FieldDeclarationInfo.hash(clazz));
+    if (candidate == null) {
+      // field is on byte code.
+      return null;
+    }
+    return new OnClass(candidate.pathToSourceFile, candidate.clazz);
+  }
 }

annotator-core/src/main/java/edu/ucr/cs/riple/core/metadata/graph/Node.java

@@ -92,8 +92,7 @@ public Node(Fix root) {
    */
   public void setOrigins(ErrorStore errorStore) {
     this.origins =
-        errorStore.getRegionsForElements(
-            error -> error.isSingleFix() && error.getResolvingFixes().contains(root));
+        errorStore.getRegionsForElements(error -> error.getResolvingFixes().contains(root));
   }
 
   /**

annotator-core/src/main/java/edu/ucr/cs/riple/core/metadata/trackers/Region.java

@@ -25,6 +25,7 @@
 package edu.ucr.cs.riple.core.metadata.trackers;
 
 import edu.ucr.cs.riple.injector.Helper;
+import edu.ucr.cs.riple.injector.location.OnClass;
 import edu.ucr.cs.riple.scanner.generatedcode.SourceType;
 import java.util.Objects;
 
@@ -53,7 +54,7 @@ public enum Type {
     METHOD,
     FIELD,
     CONSTRUCTOR,
-    STATIC_BLOCK
+    INIT_BLOCK
   }
 
   public Region(String encClass, String encMember, SourceType sourceType) {
@@ -70,12 +71,13 @@ public Region(String encClass, String encMember) {
   /**
    * Initializes {@link Region#type} based on the string representation of regionMember.
    *
-   * @param regionMember Symbol of the region representative.
+   * @param regionClass Symbol of the region class in string.
+   * @param regionMember Symbol of the region representative in string.
    * @return The corresponding Type.
    */
   public static Type getType(String regionClass, String regionMember) {
     if (regionMember.equals("null")) {
-      return Type.STATIC_BLOCK;
+      return Type.INIT_BLOCK;
     }
     if (regionMember.contains("(")) {
       return Helper.extractCallableName(regionMember).equals(Helper.simpleName(regionClass))
@@ -121,6 +123,24 @@ public boolean isOnField() {
     return type.equals(Type.FIELD);
   }
 
+  /**
+   * Checks if region targets a static initialization block.
+   *
+   * @return true, if region is targeting a static initialization block.
+   */
+  public boolean isOnInitializationBlock() {
+    return type.equals(Type.INIT_BLOCK);
+  }
+
+  /**
+   * Checks if region is inside an anonymous class.
+   *
+   * @return true, if region is inside an anonymous class.
+   */
+  public boolean isInAnonymousClass() {
+    return OnClass.isAnonymousClassFlatName(clazz);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {

annotator-core/src/test/java/edu/ucr/cs/riple/core/CoreTest.java

@@ -32,6 +32,7 @@
 import edu.ucr.cs.riple.injector.changes.AddAnnotation;
 import edu.ucr.cs.riple.injector.changes.AddMarkerAnnotation;
 import edu.ucr.cs.riple.injector.changes.AddSingleElementAnnotation;
+import edu.ucr.cs.riple.injector.location.OnClass;
 import edu.ucr.cs.riple.injector.location.OnField;
 import edu.ucr.cs.riple.injector.location.OnMethod;
 import edu.ucr.cs.riple.injector.location.OnParameter;
@@ -421,7 +422,7 @@ public void initializationErrorWithMultipleConstructors() {
   }
 
   @Test
-  public void staticBlockLocalVariableInitializationTest() {
+  public void staticAndInstanceInitializerBlockTest() {
     coreTestHelper
         .addInputLines(
             "A.java",
@@ -441,6 +442,9 @@ public void staticBlockLocalVariableInitializationTest() {
             "   }",
             "}",
             "class B {",
+            "   {",
+            "      foo().hashCode();",
+            "   }",
             "   @Nullable",
             "   public static Object foo() { return null; }",
             "   @Nullable",
@@ -450,5 +454,18 @@ public void staticBlockLocalVariableInitializationTest() {
         .addExpectedReports(new TReport(new OnField("A.java", "test.A", singleton("f")), -3))
         .enableForceResolve()
         .start();
+    List<AddAnnotation> expectedAnnotations =
+        List.of(
+            new AddMarkerAnnotation(
+                new OnField(
+                    coreTestHelper.getSourceRoot().resolve("A.java").toString(),
+                    "test.A",
+                    Set.of("f")),
+                "javax.annotation.Nullable"),
+            new AddMarkerAnnotation(
+                new OnClass(coreTestHelper.getSourceRoot().resolve("A.java").toString(), "test.B"),
+                "org.jspecify.nullness.NullUnmarked"));
+    Assert.assertEquals(
+        expectedAnnotations, coreTestHelper.getConfig().log.getInjectedAnnotations());
   }
 }

annotator-core/src/test/java/edu/ucr/cs/riple/core/DownstreamAnalysisTest.java

@@ -40,8 +40,8 @@ public void publicMethodWithDownstreamDependencyEnabled() {
     coreTestHelper
         .addExpectedReports(
             // Change reduces errors on target by -4, but increases them in downstream dependency
-            // DepA by 3, DepB by 4 and DepC by 2. Hence, the total effect is: 5.
-            new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableBad(int)"), 5),
+            // DepA by 3, DepB by 4 and DepC by 3. Hence, the total effect is: 6.
+            new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableBad(int)"), 6),
             // Change reduces errors on target by -5, but increases them in downstream dependency
             // DepA by 0, DepB by 1 and DepC by 0. Hence, the total effect is: -4.
             new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableGood(int)"), -4),
@@ -78,13 +78,13 @@ public void publicMethodWithDownstreamDependencyDisabled() {
   public void lowerBoundComputationTest() {
     coreTestHelper
         .addExpectedReports(
-            // Only returnNullableBad triggers new errors in this fix chain (+9), lower bound is 9.
-            new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableBad(int)"), 9),
+            // Only returnNullableBad triggers new errors in this fix chain (+9), lower bound is 10.
+            new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableBad(int)"), 10),
             // Only returnNullableGood triggers new errors in this fix chain (+1), lower bound is 1.
             new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableGood(int)"), 1),
             // Root fix triggers 1 error on downstream dependency but returnNullableBad is
-            // present in the fix tree, therefore the lower bound effect for the tree should be 9.
-            new TReport(new OnMethod("Foo.java", "test.target.Foo", "bar()"), 9))
+            // present in the fix tree, therefore the lower bound effect for the tree should be 10.
+            new TReport(new OnMethod("Foo.java", "test.target.Foo", "bar()"), 10))
         .setPredicate(
             (expected, found) ->
                 expected.root.equals(found.root)
@@ -100,16 +100,17 @@ public void lowerBoundComputationTest() {
   public void upperBoundComputationTest() {
     coreTestHelper
         .addExpectedReports(
-            // Only returnNullableBad triggers new errors in this fix chain (+9) and upper bound
-            // should be 9
-            new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableBad(int)"), 9),
+            // Only returnNullableBad triggers new errors in this fix chain (+10) and upper bound
+            // should be 10
+            new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableBad(int)"), 10),
             // Only returnNullableGood triggers new errors in this fix chain (+1) and upper bound
             // should be 1
             new TReport(new OnMethod("Foo.java", "test.target.Foo", "returnNullableGood(int)"), 1),
             // Root fix triggers 1 error on downstream dependency and returnNullableBad is
-            // present in the fix tree and triggers 9 errors on downstream dependency, therefore the
-            // upper bound effect for the tree should be 10.
-            new TReport(new OnMethod("Foo.java", "test.target.Foo", "bar()"), 10))
+            // present in the fix tree and triggers 10 errors on downstream dependency, therefore
+            // the
+            // upper bound effect for the tree should be 11.
+            new TReport(new OnMethod("Foo.java", "test.target.Foo", "bar()"), 11))
         .setPredicate(
             (expected, found) ->
                 expected.root.equals(found.root)

annotator-core/src/test/resources/templates/downstream-dependency-test/DepC/src/main/java/test/depc/DepC.java

@@ -29,6 +29,7 @@ public class DepC {
   Foo foo = new Foo();
   Object f;
 
+  // We get 2 errros here, assign_field_nullable and method_no_init for assigning nullable to f;
   DepC() {
     f = foo.returnNullableBad(0);
   }

annotator-core/src/test/resources/templates/downstream-dependency-test/Target/src/main/java/test/target/Foo.java

@@ -25,9 +25,8 @@
 public class Foo {
   Object field = new Object();
 
-  // Making this method will resolve 5 errors here and will introduce 1 new error here and 8 new
+  // Making this method will resolve 5 errors here and will introduce 1 new error here and 10 new
   // errors on downstream dependencies.
-  // dependencies.
   public Object returnNullableBad(int i) {
     // Just to create 5 places where it returns nullable, so making this method @Nullable will
     // resolve 5 NullAway errors

injector/src/main/java/edu/ucr/cs/riple/injector/location/LocationType.java

@@ -25,6 +25,7 @@
 package edu.ucr.cs.riple.injector.location;
 
 public enum LocationType {
+  CLASS,
   FIELD,
   METHOD,
   PARAMETER;
@@ -39,6 +40,9 @@ public static LocationType getType(String type) {
     if (type.equalsIgnoreCase("parameter")) {
       return PARAMETER;
     }
+    if (type.equalsIgnoreCase("class")) {
+      return CLASS;
+    }
     throw new UnsupportedOperationException("Cannot detect type: " + type);
   }
 }

injector/src/main/java/edu/ucr/cs/riple/injector/location/OnClass.java

@@ -0,0 +1,88 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Nima Karimipour
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package edu.ucr.cs.riple.injector.location;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.BodyDeclaration;
+import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations;
+import edu.ucr.cs.riple.injector.Helper;
+import edu.ucr.cs.riple.injector.changes.Change;
+import edu.ucr.cs.riple.injector.modifications.Modification;
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Pattern;
+import org.json.simple.JSONObject;
+
+public class OnClass extends Location {
+
+  /**
+   * Pattern to detect if a class flat name is for an anonymous class. Anonymous classes flat names
+   * ends with a $ and one or more digits.
+   */
+  public static final Pattern anonymousClassPattern = Pattern.compile(".*\\$\\d+$");
+
+  public OnClass(Path path, String clazz) {
+    super(LocationType.CLASS, path, clazz);
+  }
+
+  public OnClass(String path, String clazz) {
+    this(Helper.deserializePath(path), clazz);
+  }
+
+  @Override
+  protected Modification applyToMember(NodeList<BodyDeclaration<?>> declarations, Change change) {
+    if (isAnonymousClassFlatName(change.location.clazz)) {
+      return null;
+    }
+    final AtomicReference<Modification> ans = new AtomicReference<>();
+    Optional<Node> clazz = declarations.getParentNode();
+    clazz.ifPresent(
+        node ->
+            node.getRange()
+                .ifPresent(range -> ans.set(change.visit((NodeWithAnnotations<?>) node, range))));
+    return ans.get();
+  }
+
+  /**
+   * Checks if flat name is for an anonymous class.
+   *
+   * @return true, if flat name is for an anonymous class.
+   */
+  public static boolean isAnonymousClassFlatName(String flatName) {
+    return anonymousClassPattern.matcher(flatName).matches();
+  }
+
+  @Override
+  protected void fillJsonInformation(JSONObject res) {
+    // no op
+  }
+
+  @Override
+  public String toString() {
+    return "OnClass{" + "type=" + type + ", clazz='" + clazz + '\'' + ", path=" + path + '}';
+  }
+}