Add suppressWarnings on fields

core/build.gradle

@@ -97,5 +97,15 @@ tasks.create("configureNullAwayVersion"){
     println "NullAway Test version changed to: " + NULLAWAY_TEST
 
     // exclude unsupported tests below...
+    switch (NULLAWAY_TEST){
+        case "0.10.4":
+            test {
+                filter {
+                    excludeTest "edu.ucr.cs.riple.core.CoreTest", "errorInFieldDeclarationForceResolveTest"
+                    excludeTest "edu.ucr.cs.riple.core.CoreTest", "initializationErrorWithMultipleConstructors"
+                }
+            }
+            break
+    }
 }
 tasks.test.dependsOn("configureNullAwayVersion")

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

@@ -48,7 +48,7 @@
 import edu.ucr.cs.riple.injector.changes.AddMarkerAnnotation;
 import edu.ucr.cs.riple.injector.changes.AddSingleElementAnnotation;
 import edu.ucr.cs.riple.injector.location.OnField;
-import edu.ucr.cs.riple.injector.location.OnMethod;
+import edu.ucr.cs.riple.injector.location.OnParameter;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
@@ -267,42 +267,53 @@ private void forceResolveRemainingErrors(
                   if (error.getRegion().isOnMethod()) {
                     return tree.findNode(error.encMember(), error.encClass());
                   }
-                  if (error.nonnullTarget == null) {
-                    // Just a sanity check.
-                    return null;
-                  }
                   // For methods invoked in an initialization region, where the error is that
                   // `@Nullable` is being passed as an argument, we add a `@NullUnmarked` annotation
                   // to the called method.
-                  if (error.messageType.equals("PASS_NULLABLE")) {
-                    OnMethod calledMethod = error.nonnullTarget.toMethod();
-                    return tree.findNode(calledMethod.method, calledMethod.clazz);
+                  if (error.messageType.equals("PASS_NULLABLE")
+                      && error.nonnullTarget != null
+                      && error.nonnullTarget.isOnParameter()) {
+                    OnParameter nullableParameter = error.nonnullTarget.toParameter();
+                    return tree.findNode(nullableParameter.method, nullableParameter.clazz);
                   }
                   return null;
                 })
+            // Filter null values from map above.
             .filter(Objects::nonNull)
             .map(node -> new AddMarkerAnnotation(node.location, config.nullUnMarkedAnnotation))
             .collect(Collectors.toSet());
     injector.injectAnnotations(nullUnMarkedAnnotations);
-
     // Update log.
     config.log.updateInjectedAnnotations(nullUnMarkedAnnotations);
 
-    // Collect explicit Nullable initialization to fields
-    Set<AddAnnotation> suppressWarningsAnnotations =
-        remainingFixes.stream()
+    // Collect suppress warnings, errors on field declaration regions.
+    Set<OnField> fieldsWithSuppressWarnings =
+        remainingErrors.stream()
             .filter(
-                fix -> {
-                  if (!(fix.isOnField() && fix.reasons.contains("ASSIGN_FIELD_NULLABLE"))) {
+                error -> {
+                  if (!error.getRegion().isOnField()) {
                     return false;
                   }
-                  OnField onField = fix.toField();
-                  return onField.clazz.equals(fix.encClass()) && !fix.getRegion().isOnMethod();
+                  if (error.messageType.equals("PASS_NULLABLE")) {
+                    // It is already resolved with @NullUnmarked selected above.
+                    return false;
+                  }
+                  // We can silence them by SuppressWarnings("NullAway.Init")
+                  return !error.messageType.equals("METHOD_NO_INIT")
+                      && !error.messageType.equals("FIELD_NO_INIT");
                 })
             .map(
-                fix ->
-                    new AddSingleElementAnnotation(
-                        fix.toField(), "SuppressWarnings", "NullAway", false))
+                error ->
+                    fieldDeclarationAnalysis.getLocationOnField(
+                        error.getRegion().clazz, error.getRegion().member))
+            .filter(Objects::nonNull)
+            .collect(Collectors.toSet());
+
+    Set<AddAnnotation> suppressWarningsAnnotations =
+        fieldsWithSuppressWarnings.stream()
+            .map(
+                onField ->
+                    new AddSingleElementAnnotation(onField, "SuppressWarnings", "NullAway", false))
             .collect(Collectors.toSet());
     injector.injectAnnotations(suppressWarningsAnnotations);
     // Update log.
@@ -316,6 +327,8 @@ private void forceResolveRemainingErrors(
                     fix.isOnField()
                         && (fix.reasons.contains("METHOD_NO_INIT")
                             || fix.reasons.contains("FIELD_NO_INIT")))
+            // Filter nodes annotated with SuppressWarnings("NullAway")
+            .filter(fix -> !fieldsWithSuppressWarnings.contains(fix.toField()))
             .map(
                 fix ->
                     new AddSingleElementAnnotation(

core/src/main/java/edu/ucr/cs/riple/core/metadata/field/FieldDeclarationAnalysis.java

@@ -12,6 +12,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.OnField;
 import edu.ucr.cs.riple.scanner.TypeAnnotatorScanner;
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -77,18 +78,16 @@ protected FieldDeclarationInfo addNodeByLine(String[] values) {
         System.err.println(notFound.getMessage());
         return null;
       }
-      FieldDeclarationInfo info = new FieldDeclarationInfo(clazz);
+      FieldDeclarationInfo info = new FieldDeclarationInfo(path, clazz);
       members.forEach(
           bodyDeclaration ->
               bodyDeclaration.ifFieldDeclaration(
                   fieldDeclaration -> {
                     NodeList<VariableDeclarator> vars = fieldDeclaration.getVariables();
-                    if (vars.size() > 1) { // Check if it is an inline multiple field declaration.
-                      info.addNewSetOfFieldDeclarations(
-                          vars.stream()
-                              .map(NodeWithSimpleName::getNameAsString)
-                              .collect(ImmutableSet.toImmutableSet()));
-                    }
+                    info.addNewSetOfFieldDeclarations(
+                        vars.stream()
+                            .map(NodeWithSimpleName::getNameAsString)
+                            .collect(ImmutableSet.toImmutableSet()));
                   }));
       return info.isEmpty() ? null : info;
     } catch (FileNotFoundException e) {
@@ -116,4 +115,20 @@ public ImmutableSet<String> getInLineMultipleFieldDeclarationsOnField(
         candidate.fields.stream().filter(group -> !Collections.disjoint(group, fields)).findFirst();
     return inLineGroupFieldDeclaration.orElse(ImmutableSet.copyOf(fields));
   }
+
+  /**
+   * Creates a {@link OnField} instance targeting the passed field and class.
+   *
+   * @param clazz Enclosing class of the field.
+   * @param field Field name.
+   * @return {@link OnField} instance targeting the passed field and class.
+   */
+  public OnField getLocationOnField(String clazz, String field) {
+    FieldDeclarationInfo candidate =
+        findNodeWithHashHint(node -> node.clazz.equals(clazz), FieldDeclarationInfo.hash(clazz));
+    if (candidate == null) {
+      return null;
+    }
+    return new OnField(candidate.pathToSourceFile, candidate.clazz, Collections.singleton(field));
+  }
 }

core/src/main/java/edu/ucr/cs/riple/core/metadata/field/FieldDeclarationInfo.java

@@ -12,9 +12,12 @@ public class FieldDeclarationInfo implements Hashable {
   public final Set<ImmutableSet<String>> fields;
   /** Flat name of the containing class. */
   public final String clazz;
+  /** Path to source file containing this class. */
+  public final String pathToSourceFile;
 
-  public FieldDeclarationInfo(String clazz) {
+  public FieldDeclarationInfo(String path, String clazz) {
     this.clazz = clazz;
+    this.pathToSourceFile = path;
     this.fields = new HashSet<>();
   }
 
@@ -26,8 +29,8 @@ public boolean equals(Object o) {
     if (!(o instanceof FieldDeclarationInfo)) {
       return false;
     }
-    FieldDeclarationInfo info = (FieldDeclarationInfo) o;
-    return clazz.equals(info.clazz);
+    FieldDeclarationInfo other = (FieldDeclarationInfo) o;
+    return clazz.equals(other.clazz);
   }
 
   /**

core/src/main/java/edu/ucr/cs/riple/core/metadata/index/Enclosed.java

@@ -60,9 +60,9 @@ public String encMember() {
   /**
    * Getter for region.
    *
-   * @return region.
+   * @return region instance.
    */
   public Region getRegion() {
-    return region;
+    return this.region;
   }
 }

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

@@ -79,6 +79,15 @@ public boolean isOnMethod() {
     return type.equals(Type.METHOD);
   }
 
+  /**
+   * Checks if region targets a field declaration.
+   *
+   * @return true, if region is targeting a field declaration.
+   */
+  public boolean isOnField() {
+    return type.equals(Type.FIELD);
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {

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

@@ -29,10 +29,16 @@
 
 import com.google.common.base.Preconditions;
 import edu.ucr.cs.riple.core.tools.TReport;
+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.OnField;
 import edu.ucr.cs.riple.injector.location.OnMethod;
 import edu.ucr.cs.riple.injector.location.OnParameter;
+import java.nio.file.Path;
 import java.util.List;
+import java.util.Set;
+import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -297,6 +303,108 @@ public void deactivateInferenceTest() {
             .equals("org.jspecify.nullness.NullUnmarked"));
   }
 
+  @Test
+  public void errorInFieldDeclarationForceResolveTest() {
+    coreTestHelper
+        .addInputDirectory("test", "fielderrorregion")
+        .addExpectedReports(
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f1")), 2),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f2", "f3")), 2),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f0")), -1),
+            new TReport(new OnParameter("Bar.java", "test.Bar", "process(java.lang.Object)", 0), 1),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f4")), 1),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f5")), 0))
+        .toDepth(1)
+        .enableForceResolve()
+        .start();
+    Path srcRoot = coreTestHelper.getSourceRoot();
+    Set<AddAnnotation> expectedAnnotations =
+        Set.of(
+            new AddMarkerAnnotation(
+                new OnField(srcRoot.resolve("Foo.java").toString(), "test.Foo", Set.of("f0")),
+                "javax.annotation.Nullable"),
+            new AddMarkerAnnotation(
+                new OnMethod(
+                    srcRoot.resolve("Bar.java").toString(),
+                    "test.Bar",
+                    "process(java.lang.Object)"),
+                "org.jspecify.nullness.NullUnmarked"),
+            new AddSingleElementAnnotation(
+                new OnField(srcRoot.resolve("Foo.java").toString(), "test.Foo", Set.of("f4")),
+                "SuppressWarnings",
+                "NullAway",
+                false),
+            new AddSingleElementAnnotation(
+                new OnField(srcRoot.resolve("Foo.java").toString(), "test.Foo", Set.of("f2", "f3")),
+                "SuppressWarnings",
+                "NullAway.Init",
+                false),
+            new AddSingleElementAnnotation(
+                new OnField(srcRoot.resolve("Foo.java").toString(), "test.Foo", Set.of("f1")),
+                "SuppressWarnings",
+                "NullAway.Init",
+                false),
+            new AddMarkerAnnotation(
+                new OnField(srcRoot.resolve("Foo.java").toString(), "test.Foo", Set.of("f5")),
+                "javax.annotation.Nullable"));
+    // todo: change test infrastructure to do the expected added annotations comparison internally
+    // in the upcoming refactoring cycle.
+    Assert.assertEquals(
+        expectedAnnotations, Set.copyOf(coreTestHelper.getConfig().log.getInjectedAnnotations()));
+  }
+
+  @Test
+  public void initializationErrorWithMultipleConstructors() {
+    coreTestHelper
+        .addInputLines(
+            "Foo.java",
+            "package test;",
+            "public class Foo {",
+            "   Object f1;",
+            "   Object f2;",
+            "   Object f3;",
+            "   Object f4 = null;",
+            "   Foo() { }",
+            "   Foo(int i) { }",
+            "   Foo(int i, int j) { }",
+            "   void bar1() {",
+            "     f3.hashCode();",
+            "     f4.hashCode();",
+            "   }",
+            "   void bar2() {",
+            "     f3.hashCode();",
+            "     f4.hashCode();",
+            "   }",
+            "}")
+        .addExpectedReports(
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f1")), 0),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f2")), 0),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f3")), 2),
+            new TReport(new OnField("Foo.java", "test.Foo", Set.of("f4")), 1))
+        .toDepth(1)
+        .enableForceResolve()
+        .start();
+    String pathToFoo = coreTestHelper.getSourceRoot().resolve("Foo.java").toString();
+    Set<AddAnnotation> expectedAnnotations =
+        Set.of(
+            new AddMarkerAnnotation(
+                new OnField(pathToFoo, "test.Foo", Set.of("f1")), "javax.annotation.Nullable"),
+            new AddMarkerAnnotation(
+                new OnField(pathToFoo, "test.Foo", Set.of("f2")), "javax.annotation.Nullable"),
+            new AddSingleElementAnnotation(
+                new OnField(pathToFoo, "test.Foo", Set.of("f3")),
+                "SuppressWarnings",
+                "NullAway.Init",
+                false),
+            new AddSingleElementAnnotation(
+                new OnField(pathToFoo, "test.Foo", Set.of("f4")),
+                "SuppressWarnings",
+                "NullAway",
+                false));
+    Assert.assertEquals(
+        expectedAnnotations, Set.copyOf(coreTestHelper.getConfig().log.getInjectedAnnotations()));
+  }
+
   @Test
   public void staticBlockLocalVariableInitializationTest() {
     coreTestHelper

core/src/test/java/edu/ucr/cs/riple/core/tools/CoreTestHelper.java

@@ -321,4 +321,19 @@ public Config getConfig() {
     }
     return config;
   }
+
+  /**
+   * Returns path to src directory where all test inputs exist.
+   *
+   * @return Path to root src directory.
+   */
+  public Path getSourceRoot() {
+    return getConfig()
+        .globalDir
+        .resolve("unittest")
+        .resolve("src")
+        .resolve("main")
+        .resolve("java")
+        .resolve("test");
+  }
 }

core/src/test/resources/fielderrorregion/Bar.java

@@ -0,0 +1,22 @@
+package test;
+
+import javax.annotation.Nullable;
+
+public class Bar {
+
+  Object foo = new Object();
+
+  public void deref() {}
+
+  @Nullable
+  public Bar process(Object foo) {
+    this.foo = foo;
+    receiveNonnull(foo);
+    return null;
+  }
+
+  public Object receiveNonnull(Object o) {
+    // just to keep Bar#process:foo @Nonnull
+    return o;
+  }
+}