Add support for external init annotations in constructors

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

@@ -157,6 +157,9 @@ public interface Config {
    * Checks if annotation marks an "external-init class," i.e., a class where some external
    * framework initializes object fields after invoking the zero-argument constructor.
    *
+   * <p>Note that this annotation can be on the class itself, or on the zero-arguments constructor,
+   * but will be ignored anywhere else.
+   *
    * @param annotationName fully-qualified annotation name
    * @return true if classes with the annotation are external-init
    */

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

@@ -1761,7 +1761,8 @@ private void checkFieldInitialization(ClassTree tree, VisitorState state) {
       } else if (constructorInitInfo == null) {
         // report it on the field, except in the case where the class is externalInit and
         // we have no initializer methods
-        if (!(isExternalInit(classSymbol) && entities.instanceInitializerMethods().isEmpty())) {
+        if (!(symbolHasExternalInitAnnotation(classSymbol)
+            && entities.instanceInitializerMethods().isEmpty())) {
           errorBuilder.reportInitErrorOnField(
               uninitField, state, buildDescription(getTreesInstance(state).getTree(uninitField)));
         }
@@ -1868,12 +1869,14 @@ private SetMultimap<MethodTree, Symbol> checkConstructorInitialization(
     SetMultimap<MethodTree, Symbol> result = LinkedHashMultimap.create();
     Set<Symbol> nonnullInstanceFields = entities.nonnullInstanceFields();
     Trees trees = getTreesInstance(state);
-    boolean isExternalInit = isExternalInit(entities.classSymbol());
+    boolean isExternalInitClass = symbolHasExternalInitAnnotation(entities.classSymbol());
     for (MethodTree constructor : entities.constructors()) {
       if (constructorInvokesAnother(constructor, state)) {
         continue;
       }
-      if (constructor.getParameters().size() == 0 && isExternalInit) {
+      if (constructor.getParameters().size() == 0
+          && (isExternalInitClass
+              || symbolHasExternalInitAnnotation(ASTHelpers.getSymbol(constructor)))) {
         // external framework initializes fields in this case
         continue;
       }
@@ -1888,8 +1891,8 @@ private SetMultimap<MethodTree, Symbol> checkConstructorInitialization(
     return result;
   }
 
-  private boolean isExternalInit(Symbol.ClassSymbol classSymbol) {
-    return StreamSupport.stream(NullabilityUtil.getAllAnnotations(classSymbol).spliterator(), false)
+  private boolean symbolHasExternalInitAnnotation(Symbol symbol) {
+    return StreamSupport.stream(NullabilityUtil.getAllAnnotations(symbol).spliterator(), false)
         .map((anno) -> anno.getAnnotationType().toString())
         .anyMatch(config::isExternalInitClassAnnotation);
   }

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

@@ -1,5 +1,6 @@
 package com.uber.nullaway;
 
+import java.util.Arrays;
 import org.junit.Test;
 
 public class NullAwayInitializationTests extends NullAwayTestsBase {
@@ -68,6 +69,59 @@ public void externalInitSupport() {
         .doTest();
   }
 
+  @Test
+  public void externalInitSupportConstructors() {
+    makeTestHelperWithArgs(
+            Arrays.asList(
+                "-d",
+                temporaryFolder.getRoot().getAbsolutePath(),
+                "-XepOpt:NullAway:AnnotatedPackages=com.uber",
+                "-XepOpt:NullAway:ExternalInitAnnotations=com.uber.ExternalInitConstructor"))
+        .addSourceLines(
+            "ExternalInitConstructor.java",
+            "package com.uber;",
+            "import java.lang.annotation.ElementType;",
+            "import java.lang.annotation.Retention;",
+            "import java.lang.annotation.RetentionPolicy;",
+            "import java.lang.annotation.Target;",
+            "@Retention(RetentionPolicy.CLASS)",
+            "@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})",
+            "public @interface ExternalInitConstructor {}")
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "class Test {",
+            "  Object f;",
+            // no error here due to external init
+            "  @ExternalInitConstructor",
+            "  public Test() {}",
+            "  // BUG: Diagnostic contains: initializer method does not guarantee @NonNull field",
+            "  public Test(int x) {}",
+            "  public Test(Object o) { this.f = o; }",
+            "}")
+        .addSourceLines(
+            "Test2.java",
+            "package com.uber;",
+            "class Test2 {",
+            "  // BUG: Diagnostic contains: @NonNull field f not initialized",
+            "  Object f;",
+            // must be on a constructor!
+            "  @ExternalInitConstructor",
+            "  public void init() {}",
+            "}")
+        .addSourceLines(
+            "Test3.java",
+            "package com.uber;",
+            "class Test3 {",
+            "  Object f;",
+            // Must be zero-args constructor!
+            "  @ExternalInitConstructor",
+            "  // BUG: Diagnostic contains: initializer method does not guarantee @NonNull field",
+            "  public Test3(int x) {}",
+            "}")
+        .doTest();
+  }
+
   @Test
   public void externalInitSupportFields() {
     defaultCompilationHelper