Support @EnsuresNonNullIf

annotations/src/main/java/com/uber/nullaway/annotations/EnsuresNonNullIf.java

@@ -0,0 +1,40 @@
+package com.uber.nullaway.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation describing a nullability post-condition for an instance method. Each parameter to
+ * the annotation should be a field of the enclosing class. The method must ensure that the method
+ * returns true in case the fields are non-null. The method can also return true in case the fields
+ * are null (inverse logic), and in such case, you must set trueIfNonNull to false. NullAway
+ * verifies that the property holds.
+ *
+ * <p>Here is an example:
+ *
+ * <pre>
+ * class Foo {
+ *     {@literal @}Nullable Object theField;
+ *     {@literal @}EnsuresNonNullIf("theField") // @EnsuresNonNullIf("this.theField") is also valid
+ *     boolean hasTheField() {
+ *         return theField != null;
+ *     }
+ *     void bar() {
+ *         if(!hasTheField()) {
+ *             return;
+ *         }
+ *         // No error, NullAway knows theField is non-null after call to hasTheField()
+ *         theField.toString();
+ *     }
+ * }
+ * </pre>
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.METHOD})
+public @interface EnsuresNonNullIf {
+  String[] value();
+
+  boolean trueIfNonNull() default true;
+}

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

@@ -230,14 +230,7 @@ public static Stream<? extends AnnotationMirror> getAllAnnotations(Symbol symbol
    */
   public static @Nullable Set<String> getAnnotationValueArray(
       Symbol.MethodSymbol methodSymbol, String annotName, boolean exactMatch) {
-    AnnotationMirror annot = null;
-    for (AnnotationMirror annotationMirror : methodSymbol.getAnnotationMirrors()) {
-      String name = AnnotationUtils.annotationName(annotationMirror);
-      if ((exactMatch && name.equals(annotName)) || (!exactMatch && name.endsWith(annotName))) {
-        annot = annotationMirror;
-        break;
-      }
-    }
+    AnnotationMirror annot = findAnnotation(methodSymbol, annotName, exactMatch);
     if (annot == null) {
       return null;
     }
@@ -255,6 +248,22 @@ public static Stream<? extends AnnotationMirror> getAllAnnotations(Symbol symbol
     return null;
   }
 
+  public static @Nullable AnnotationMirror findAnnotation(
+      Symbol.MethodSymbol methodSymbol, String annotName, boolean exactMatch) {
+    AnnotationMirror annot = null;
+    for (AnnotationMirror annotationMirror : methodSymbol.getAnnotationMirrors()) {
+      String name = AnnotationUtils.annotationName(annotationMirror);
+      if ((exactMatch && name.equals(annotName)) || (!exactMatch && name.endsWith(annotName))) {
+        annot = annotationMirror;
+        break;
+      }
+    }
+    if (annot == null) {
+      return null;
+    }
+    return annot;
+  }
+
   /**
    * Works for method parameters defined either in source or in class files
    *

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

@@ -53,6 +53,11 @@ public abstract class AbstractFieldContractHandler extends BaseNoOpHandler {
   /** Simple name of the annotation in {@code String} */
   protected final String annotName;
 
+  // Set to true in case we are visiting a method with the annotation under analysis
+  protected boolean visitingAnnotatedMethod;
+  // Points to the method symbol that's currently being visited
+  protected Symbol.MethodSymbol visitingMethodSymbol;
+
   protected AbstractFieldContractHandler(String annotName) {
     this.annotName = annotName;
   }
@@ -65,12 +70,13 @@ protected AbstractFieldContractHandler(String annotName) {
    */
   @Override
   public void onMatchMethod(MethodTree tree, MethodAnalysisContext methodAnalysisContext) {
-
     Symbol.MethodSymbol methodSymbol = methodAnalysisContext.methodSymbol();
     VisitorState state = methodAnalysisContext.state();
     Set<String> annotationContent =
         NullabilityUtil.getAnnotationValueArray(methodSymbol, annotName, false);
     boolean isAnnotated = annotationContent != null;
+    this.visitingAnnotatedMethod = isAnnotated;
+    this.visitingMethodSymbol = methodSymbol;
     boolean isValid =
         isAnnotated
             && validateAnnotationSyntax(

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

@@ -27,6 +27,7 @@
 import com.uber.nullaway.handlers.contract.ContractCheckHandler;
 import com.uber.nullaway.handlers.contract.ContractHandler;
 import com.uber.nullaway.handlers.contract.fieldcontract.EnsuresNonNullHandler;
+import com.uber.nullaway.handlers.contract.fieldcontract.EnsuresNonNullIfHandler;
 import com.uber.nullaway.handlers.contract.fieldcontract.RequiresNonNullHandler;
 import com.uber.nullaway.handlers.temporary.FluentFutureHandler;
 
@@ -69,6 +70,7 @@ public static Handler buildDefault(Config config) {
     handlerListBuilder.add(new GrpcHandler());
     handlerListBuilder.add(new RequiresNonNullHandler());
     handlerListBuilder.add(new EnsuresNonNullHandler());
+    handlerListBuilder.add(new EnsuresNonNullIfHandler());
     handlerListBuilder.add(new SynchronousCallbackHandler());
     if (config.serializationIsActive() && config.getSerializationConfig().fieldInitInfoEnabled) {
       handlerListBuilder.add(

nullaway/src/main/java/com/uber/nullaway/handlers/contract/fieldcontract/EnsuresNonNullHandler.java

@@ -40,7 +40,6 @@
 import com.uber.nullaway.handlers.MethodAnalysisContext;
 import com.uber.nullaway.handlers.contract.ContractUtils;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.Set;
 import java.util.stream.Collectors;
 import javax.lang.model.element.VariableElement;
@@ -124,46 +123,8 @@ protected void validateOverridingRules(
       VisitorState state,
       MethodTree tree,
       Symbol.MethodSymbol overriddenMethod) {
-    Set<String> overriddenFieldNames = getAnnotationValueArray(overriddenMethod, annotName, false);
-    if (overriddenFieldNames == null) {
-      return;
-    }
-    if (overridingFieldNames == null) {
-      overridingFieldNames = Collections.emptySet();
-    }
-    if (overridingFieldNames.containsAll(overriddenFieldNames)) {
-      return;
-    }
-    overriddenFieldNames.removeAll(overridingFieldNames);
-
-    StringBuilder errorMessage = new StringBuilder();
-    errorMessage
-        .append(
-            "postcondition inheritance is violated, this method must guarantee that all fields written in the @EnsuresNonNull annotation of overridden method ")
-        .append(castToNonNull(ASTHelpers.enclosingClass(overriddenMethod)).getSimpleName())
-        .append(".")
-        .append(overriddenMethod.getSimpleName())
-        .append(" are @NonNull at exit point as well. Fields [");
-    Iterator<String> iterator = overriddenFieldNames.iterator();
-    while (iterator.hasNext()) {
-      errorMessage.append(iterator.next());
-      if (iterator.hasNext()) {
-        errorMessage.append(", ");
-      }
-    }
-    errorMessage.append(
-        "] must explicitly appear as parameters at this method @EnsuresNonNull annotation");
-    state.reportMatch(
-        analysis
-            .getErrorBuilder()
-            .createErrorDescription(
-                new ErrorMessage(
-                    ErrorMessage.MessageTypes.WRONG_OVERRIDE_POSTCONDITION,
-                    errorMessage.toString()),
-                tree,
-                analysis.buildDescription(tree),
-                state,
-                null));
+    FieldContractUtils.validateOverridingRules(
+        annotName, overridingFieldNames, analysis, state, tree, overriddenMethod);
   }
 
   /**