Persist the nullness of parameters for AssistedFactory overrides

dagger-compiler/main/java/dagger/internal/codegen/writing/AssistedFactoryRequestRepresentation.java

@@ -97,7 +97,9 @@ private XTypeSpec anonymousfactoryImpl(
         XTypeSpecs.anonymousClassBuilder()
             .addFunction(
                 overridingWithoutParameters(factoryMethod, factoryType, compilerOptions)
-                    .addParameters(assistedFactoryParameterSpecs(binding, shardImplementation))
+                    .addParameters(
+                        assistedFactoryParameterSpecs(
+                            binding, shardImplementation, compilerOptions))
                     .addStatement(
                         "return %L",
                         requiresCast(returnType, shardImplementation.name())

dagger-compiler/main/java/dagger/internal/codegen/writing/AssistedInjectionParameters.java

@@ -32,8 +32,10 @@
 import dagger.internal.codegen.binding.AssistedInjectionAnnotations;
 import dagger.internal.codegen.binding.AssistedInjectionAnnotations.AssistedFactoryMetadata;
 import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
 import dagger.internal.codegen.model.BindingKind;
 import dagger.internal.codegen.writing.ComponentImplementation.ShardImplementation;
+import dagger.internal.codegen.xprocessing.Nullability;
 import dagger.internal.codegen.xprocessing.XParameterSpecs;
 import java.util.List;
 
@@ -47,7 +49,7 @@ final class AssistedInjectionParameters {
    * dagger.assisted.AssistedInject}-annotated constructor.
    */
   public static ImmutableList<XParameterSpec> assistedFactoryParameterSpecs(
-      Binding binding, ShardImplementation shardImplementation) {
+      Binding binding, ShardImplementation shardImplementation, CompilerOptions compilerOptions) {
     checkArgument(binding.kind() == BindingKind.ASSISTED_FACTORY);
     XTypeElement factory = asTypeElement(binding.bindingElement().get());
     AssistedFactoryMetadata metadata = AssistedFactoryMetadata.create(factory.getType());
@@ -60,7 +62,8 @@ public static ImmutableList<XParameterSpec> assistedFactoryParameterSpecs(
             .map(metadata.assistedInjectAssistedParametersMap()::get)
             .collect(toImmutableList()),
         factoryMethodType.getParameterTypes(),
-        shardImplementation);
+        shardImplementation,
+        compilerOptions);
   }
 
   /**
@@ -71,18 +74,22 @@ public static ImmutableList<XParameterSpec> assistedFactoryParameterSpecs(
    * dagger.assisted.AssistedInject}-annotated constructor.
    */
   public static ImmutableList<XParameterSpec> assistedParameterSpecs(
-      Binding binding, ShardImplementation shardImplementation) {
+      Binding binding, ShardImplementation shardImplementation, CompilerOptions compilerOptions) {
     checkArgument(binding.kind() == BindingKind.ASSISTED_INJECTION);
     XConstructorElement constructor = asConstructor(binding.bindingElement().get());
     XConstructorType constructorType = constructor.asMemberOf(binding.key().type().xprocessing());
     return assistedParameterSpecs(
-        constructor.getParameters(), constructorType.getParameterTypes(), shardImplementation);
+        constructor.getParameters(),
+        constructorType.getParameterTypes(),
+        shardImplementation,
+        compilerOptions);
   }
 
   private static ImmutableList<XParameterSpec> assistedParameterSpecs(
       List<XExecutableParameterElement> paramElements,
       List<XType> paramTypes,
-      ShardImplementation shardImplementation) {
+      ShardImplementation shardImplementation,
+      CompilerOptions compilerOptions) {
     ImmutableList.Builder<XParameterSpec> assistedParameterSpecs = ImmutableList.builder();
     for (int i = 0; i < paramElements.size(); i++) {
       XExecutableParameterElement paramElement = paramElements.get(i);
@@ -91,7 +98,9 @@ private static ImmutableList<XParameterSpec> assistedParameterSpecs(
         assistedParameterSpecs.add(
             XParameterSpecs.of(
                 shardImplementation.getUniqueFieldNameForAssistedParam(paramElement),
-                paramType.asTypeName()));
+                paramType.asTypeName(),
+                Nullability.of(paramElement),
+                compilerOptions));
       }
     }
     return assistedParameterSpecs.build();

javatests/dagger/internal/codegen/AssistedFactoryTest.java

@@ -102,6 +102,55 @@ public void testAssistedFactory() throws Exception {
             });
   }
 
+  @Test
+  public void testAssistedFactory_nullableAssistedParam() throws Exception {
+    Source foo =
+        CompilerTests.javaSource(
+            "test.Foo",
+            "package test;",
+            "",
+            "import dagger.assisted.Assisted;",
+            "import dagger.assisted.AssistedInject;",
+            "import javax.annotation.Nullable;",
+            "",
+            "class Foo {",
+            "  @AssistedInject",
+            "  Foo(@Assisted @Nullable String str) {}",
+            "}");
+
+    Source fooFactory =
+        CompilerTests.javaSource(
+            "test.FooFactory",
+            "package test;",
+            "",
+            "import dagger.assisted.AssistedFactory;",
+            "",
+            "@AssistedFactory",
+            "interface FooFactory {",
+            "  Foo create(String factoryStr);",
+            "}");
+
+    Source component =
+        CompilerTests.javaSource(
+            "test.TestComponent",
+            "package test;",
+            "",
+            "import dagger.Component;",
+            "",
+            "@Component",
+            "interface TestComponent {",
+            "  FooFactory fooFactory();",
+            "}");
+
+    CompilerTests.daggerCompiler(foo, fooFactory, component)
+        .withProcessingOptions(compilerMode.processorOptions())
+        .compile(
+            subject -> {
+              subject.hasErrorCount(0);
+              subject.generatedSource(goldenFileRule.goldenSource("test/DaggerTestComponent"));
+            });
+  }
+
   @Test
   public void testAssistedFactoryCycle() throws Exception {
     Source foo =

javatests/dagger/internal/codegen/goldens/AssistedFactoryTest/testAssistedFactory_nullableAssistedParam/test.DaggerTestComponent_DEFAULT_MODE

@@ -0,0 +1,66 @@
+package test;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
+import javax.annotation.processing.Generated;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+final class DaggerTestComponent {
+  private DaggerTestComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static TestComponent create() {
+    return new Builder().build();
+  }
+
+  static final class Builder {
+    private Builder() {
+    }
+
+    public TestComponent build() {
+      return new TestComponentImpl();
+    }
+  }
+
+  private static final class TestComponentImpl implements TestComponent {
+    private final TestComponentImpl testComponentImpl = this;
+
+    Foo_Factory fooProvider;
+
+    Provider<FooFactory> fooFactoryProvider;
+
+    TestComponentImpl() {
+
+      initialize();
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize() {
+      this.fooProvider = Foo_Factory.create();
+      this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider);
+    }
+
+    @Override
+    public FooFactory fooFactory() {
+      return fooFactoryProvider.get();
+    }
+  }
+}

javatests/dagger/internal/codegen/goldens/AssistedFactoryTest/testAssistedFactory_nullableAssistedParam/test.DaggerTestComponent_FAST_INIT_MODE

@@ -0,0 +1,92 @@
+package test;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
+import dagger.internal.SingleCheck;
+import javax.annotation.Nullable;
+import javax.annotation.processing.Generated;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+final class DaggerTestComponent {
+  private DaggerTestComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static TestComponent create() {
+    return new Builder().build();
+  }
+
+  static final class Builder {
+    private Builder() {
+    }
+
+    public TestComponent build() {
+      return new TestComponentImpl();
+    }
+  }
+
+  private static final class TestComponentImpl implements TestComponent {
+    private final TestComponentImpl testComponentImpl = this;
+
+    Provider<FooFactory> fooFactoryProvider;
+
+    TestComponentImpl() {
+
+      initialize();
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize() {
+      this.fooFactoryProvider = SingleCheck.provider(new SwitchingProvider<FooFactory>(testComponentImpl, 0));
+    }
+
+    @Override
+    public FooFactory fooFactory() {
+      return fooFactoryProvider.get();
+    }
+
+    private static final class SwitchingProvider<T> implements Provider<T> {
+      private final TestComponentImpl testComponentImpl;
+
+      private final int id;
+
+      SwitchingProvider(TestComponentImpl testComponentImpl, int id) {
+        this.testComponentImpl = testComponentImpl;
+        this.id = id;
+      }
+
+      @Override
+      @SuppressWarnings("unchecked")
+      public T get() {
+        switch (id) {
+          case 0: // test.FooFactory
+          return (T) new FooFactory() {
+            @Override
+            public Foo create(@Nullable String str) {
+              return new Foo(str);
+            }
+          };
+
+          default: throw new AssertionError(id);
+        }
+      }
+    }
+  }
+}

javatests/dagger/internal/codegen/goldens/AssistedFactoryTest/testAssistedFactory_nullableAssistedParam/test.DaggerTestComponent_KT_DEFAULT_MODE

@@ -0,0 +1,69 @@
+package test;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Provider;
+import javax.annotation.processing.Generated;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+final class DaggerTestComponent {
+  private DaggerTestComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static TestComponent create() {
+    return new Builder().build();
+  }
+
+  static final class Builder {
+    private Builder() {
+    }
+
+    public TestComponent build() {
+      return new TestComponentImpl();
+    }
+  }
+
+  private static final class TestComponentImpl implements TestComponent {
+    private final TestComponentImpl testComponentImpl = this;
+
+    Foo_Factory fooProvider;
+
+    /**
+     * {@code Provider<FooFactory>}
+     */
+    Provider<?> fooFactoryProvider;
+
+    TestComponentImpl() {
+
+      initialize();
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize() {
+      this.fooProvider = Foo_Factory.create();
+      this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider);
+    }
+
+    @Override
+    public FooFactory fooFactory() {
+      return (FooFactory) ((Object) (fooFactoryProvider.get()));
+    }
+  }
+}