Extend library models to mark fields as nullable

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

@@ -131,6 +131,14 @@
    */
   ImmutableSetMultimap<MethodRef, Integer> castToNonNullMethods();
 
+  /**
+   * Get the set of library fields that may be null. This is mostly used to index the impact of
+   * making fields <code>@Nullable</code> on downstream dependencies.
+   *
+   * @return set of library fields that may be <code>null</code>.
+   */
+  ImmutableSet<FieldRef> nullableFields();
+
   /**
    * Get a list of custom stream library specifications.
    *
@@ -244,4 +252,58 @@
           + '}';
     }
   }
+
+  /** Representation of a field as a qualified class name + a field name */
+  final class FieldRef {
+
+    public final String enclosingClass;
+
+    public final String fieldName;
+
+    private FieldRef(String enclosingClass, String fieldName) {
+      this.enclosingClass = enclosingClass;
+      this.fieldName = fieldName;
+    }
+
+    /**
+     * Construct a field reference.
+     *
+     * @param enclosingClass containing flat name class
+     * @param fieldName field name
+     * @return corresponding {@link FieldRef}
+     */
+    public static FieldRef fieldRef(String enclosingClass, String fieldName) {
+      return new FieldRef(enclosingClass, fieldName);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      FieldRef fieldRef = (FieldRef) o;
+      return Objects.equals(enclosingClass, fieldRef.enclosingClass)
+          && Objects.equals(fieldName, fieldRef.fieldName);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(enclosingClass, fieldName);
+    }
+
+    @Override
+    public String toString() {
+      return "FieldRef{"
+          + "enclosingClass='"
+          + enclosingClass
+          + '\''
+          + ", field name='"
+          + fieldName
+          + '\''
+          + '}';
+    }
+  }
 }

nullaway/src/main/java/com/uber/nullaway/handlers/LibraryModelsHandler.java

@@ -57,6 +57,7 @@
 import java.util.Set;
 import java.util.function.Function;
 import javax.annotation.Nullable;
+import org.checkerframework.nullaway.dataflow.cfg.node.FieldAccessNode;
 import org.checkerframework.nullaway.dataflow.cfg.node.MethodInvocationNode;
 import org.checkerframework.nullaway.dataflow.cfg.node.Node;
 
@@ -80,6 +81,20 @@ public LibraryModelsHandler(Config config) {
     libraryModels = loadLibraryModels(config);
   }
 
+  @Override
+  public NullnessHint onDataflowVisitFieldAccess(
+      FieldAccessNode node,
+      Symbol symbol,
+      Types types,
+      Context context,
+      AccessPath.AccessPathContext apContext,
+      AccessPathNullnessPropagation.SubNodeValues inputs,
+      AccessPathNullnessPropagation.Updates updates) {
+    return isNullableFieldInLibraryModels(symbol)
+        ? NullnessHint.HINT_NULLABLE
+        : NullnessHint.UNKNOWN;
+  }
+
   @Override
   public Nullness[] onOverrideMethodInvocationParametersNullability(
       VisitorState state,
@@ -132,6 +147,9 @@ public boolean onOverrideMayBeNullExpr(
       @Nullable Symbol exprSymbol,
       VisitorState state,
       boolean exprMayBeNull) {
+    if (isNullableFieldInLibraryModels(exprSymbol)) {
+      return true;
+    }
     if (!(expr.getKind() == Tree.Kind.METHOD_INVOCATION
         && exprSymbol instanceof Symbol.MethodSymbol)) {
       return exprMayBeNull;
@@ -233,6 +251,34 @@ public NullnessHint onDataflowVisitMethodInvocation(
     }
   }
 
+  /**
+   * Check if the given symbol is a field that is marked as nullable in any of our library models.
+   *
+   * @param symbol The symbol to check.
+   * @return True if the symbol is a field that is marked as nullable in any of our library models.
+   */
+  private boolean isNullableFieldInLibraryModels(@Nullable Symbol symbol) {
+    if (symbol instanceof Symbol.VarSymbol && symbol.getKind().isField()) {
+      Symbol.VarSymbol varSymbol = (Symbol.VarSymbol) symbol;
+      Symbol.ClassSymbol classSymbol = varSymbol.enclClass();
+      if (classSymbol == null) {
+        // e.g. .class expressions
+        return false;
+      }
+      String fieldName = varSymbol.getSimpleName().toString();
+      String enclosingClassName = classSymbol.flatName().toString();
+      // check presence. This is a bit inefficient, but it's only used while indexing impact of
+      // making fields @Nullable on downstream dependencies. Also, the set of nullable fields is not
+      // expected to be large. We can optimize in future if needed.
+      return libraryModels.nullableFields().stream()
+          .anyMatch(
+              fieldRef ->
+                  fieldRef.fieldName.equals(fieldName)
+                      && fieldRef.enclosingClass.equals(enclosingClassName));
+    }
+    return false;
+  }
+
   private void setConditionalArgumentNullness(
       AccessPathNullnessPropagation.Updates thenUpdates,
       AccessPathNullnessPropagation.Updates elseUpdates,
@@ -824,6 +870,12 @@ public ImmutableSet<MethodRef> nonNullReturns() {
     public ImmutableSetMultimap<MethodRef, Integer> castToNonNullMethods() {
       return CAST_TO_NONNULL_METHODS;
     }
+
+    @Override
+    public ImmutableSet<FieldRef> nullableFields() {
+      // No nullable field by default.
+      return ImmutableSet.of();
+    }
   }
 
   private static class CombinedLibraryModels implements LibraryModels {
@@ -846,6 +898,8 @@ private static class CombinedLibraryModels implements LibraryModels {
 
     private final ImmutableSet<MethodRef> nonNullReturns;
 
+    private final ImmutableSet<FieldRef> nullableFields;
+
     private final ImmutableSetMultimap<MethodRef, Integer> castToNonNullMethods;
 
     private final ImmutableList<StreamTypeRecord> customStreamNullabilitySpecs;
@@ -870,6 +924,7 @@ public CombinedLibraryModels(Iterable<LibraryModels> models, Config config) {
           new ImmutableSetMultimap.Builder<>();
       ImmutableList.Builder<StreamTypeRecord> customStreamNullabilitySpecsBuilder =
           new ImmutableList.Builder<>();
+      ImmutableSet.Builder<FieldRef> nullableFieldsBuilder = new ImmutableSet.Builder<>();
       for (LibraryModels libraryModels : models) {
         for (Map.Entry<MethodRef, Integer> entry : libraryModels.failIfNullParameters().entries()) {
           if (shouldSkipModel(entry.getKey())) {
@@ -932,6 +987,9 @@ public CombinedLibraryModels(Iterable<LibraryModels> models, Config config) {
         for (StreamTypeRecord streamTypeRecord : libraryModels.customStreamNullabilitySpecs()) {
           customStreamNullabilitySpecsBuilder.add(streamTypeRecord);
         }
+        for (FieldRef fieldRef : libraryModels.nullableFields()) {
+          nullableFieldsBuilder.add(fieldRef);
+        }
       }
       failIfNullParameters = failIfNullParametersBuilder.build();
       explicitlyNullableParameters = explicitlyNullableParametersBuilder.build();
@@ -943,6 +1001,7 @@ public CombinedLibraryModels(Iterable<LibraryModels> models, Config config) {
       nonNullReturns = nonNullReturnsBuilder.build();
       castToNonNullMethods = castToNonNullMethodsBuilder.build();
       customStreamNullabilitySpecs = customStreamNullabilitySpecsBuilder.build();
+      nullableFields = nullableFieldsBuilder.build();
     }
 
     private boolean shouldSkipModel(MethodRef key) {
@@ -989,6 +1048,11 @@ public ImmutableSet<MethodRef> nonNullReturns() {
       return nonNullReturns;
     }
 
+    @Override
+    public ImmutableSet<FieldRef> nullableFields() {
+      return nullableFields;
+    }
+
     @Override
     public ImmutableSetMultimap<MethodRef, Integer> castToNonNullMethods() {
       return castToNonNullMethods;

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

@@ -227,4 +227,34 @@ public void libraryModelsAndSelectiveSkippingViaCommandLineOptions2() {
             "}")
         .doTest();
   }
+
+  @Test
+  public void libraryModelsAndOverridingFieldNullability() {
+    makeLibraryModelsTestHelperWithArgs(
+            Arrays.asList(
+                "-d",
+                temporaryFolder.getRoot().getAbsolutePath(),
+                "-XepOpt:NullAway:AnnotatedPackages=com.uber"))
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import com.uber.lib.unannotated.UnannotatedWithModels;",
+            "public class Test {",
+            "   UnannotatedWithModels uwm = new UnannotatedWithModels();",
+            "   Object nonnullField = new Object();",
+            "   void assignNullableFromLibraryModelField() {",
+            "      // BUG: Diagnostic contains: assigning @Nullable",
+            "      this.nonnullField = uwm.nullableFieldUnannotated1;",
+            "      // BUG: Diagnostic contains: assigning @Nullable",
+            "      this.nonnullField = uwm.nullableFieldUnannotated2;",
+            "   }",
+            "   void flowTest() {",
+            "      if(uwm.nullableFieldUnannotated1 != null){",
+            "      // no error here, to check that library models only initialize flow store",
+            "      this.nonnullField = uwm.nullableFieldUnannotated1;",
+            "      }",
+            "   }",
+            "}")
+        .doTest();
+  }
 }

sample-library-model/src/main/java/com/uber/modelexample/ExampleLibraryModels.java

@@ -71,4 +71,9 @@ public ImmutableSet<MethodRef> nonNullReturns() {
   public ImmutableSetMultimap<MethodRef, Integer> castToNonNullMethods() {
     return ImmutableSetMultimap.of();
   }
+
+  @Override
+  public ImmutableSet<FieldRef> nullableFields() {
+    return ImmutableSet.of();
+  }
 }

test-java-lib/src/main/java/com/uber/lib/unannotated/UnannotatedWithModels.java

@@ -2,6 +2,10 @@
 
 public class UnannotatedWithModels {
 
+  public Object nullableFieldUnannotated1;
+
+  public Object nullableFieldUnannotated2;
+
   public Object returnsNullUnannotated() {
     return null;
   }

test-library-models/src/main/java/com/uber/nullaway/testlibrarymodels/TestLibraryModels.java

@@ -15,6 +15,7 @@
  */
 package com.uber.nullaway.testlibrarymodels;
 
+import static com.uber.nullaway.LibraryModels.FieldRef.fieldRef;
 import static com.uber.nullaway.LibraryModels.MethodRef.methodRef;
 
 import com.google.auto.service.AutoService;
@@ -122,4 +123,13 @@ public ImmutableList<StreamTypeRecord> customStreamNullabilitySpecs() {
         .withPassthroughMethodFromSignature("distinct()")
         .end();
   }
+
+  @Override
+  public ImmutableSet<FieldRef> nullableFields() {
+    return ImmutableSet.<FieldRef>builder()
+        .add(
+            fieldRef("com.uber.lib.unannotated.UnannotatedWithModels", "nullableFieldUnannotated1"),
+            fieldRef("com.uber.lib.unannotated.UnannotatedWithModels", "nullableFieldUnannotated2"))
+        .build();
+  }
 }