Fix type use nullable annotations

RELNOTES=N/A
PiperOrigin-RevId: 720277354

Author: java-team-github-bot

java/dagger/internal/DaggerCollections.java

@@ -61,7 +61,7 @@ public static <T> List<T> presizedList(int size) {
    * Creates a {@link HashSet} instance, with a high enough "intial capcity" that it <em>should</em>
    * hold {@code expectedSize} elements without growth.
    */
-  static <T> HashSet<T> newHashSetWithExpectedSize(int expectedSize) {
+  static <T extends @Nullable Object> HashSet<T> newHashSetWithExpectedSize(int expectedSize) {
     return new HashSet<T>(calculateInitialCapacity(expectedSize));
   }
 

java/dagger/internal/DoubleCheck.java

@@ -77,7 +77,8 @@ public T get() {
   }
 
   /** Returns a {@link Provider} that caches the value from the given delegate provider. */
-  public static <T> dagger.internal.Provider<T> provider(dagger.internal.Provider<T> delegate) {
+  public static <T extends @Nullable Object> dagger.internal.Provider<T> provider(
+      dagger.internal.Provider<T> delegate) {
     checkNotNull(delegate);
     if (delegate instanceof DoubleCheck) {
       /* This should be a rare case, but if we have a scoped @Binds that delegates to a scoped
@@ -98,7 +99,7 @@ public static <P extends javax.inject.Provider<T>, T> javax.inject.Provider<T> p
   }
 
   /** Returns a {@link Lazy} that caches the value from the given provider. */
-  public static <T> Lazy<T> lazy(Provider<T> provider) {
+  public static <T extends @Nullable Object> Lazy<T> lazy(Provider<T> provider) {
     if (provider instanceof Lazy) {
       @SuppressWarnings("unchecked")
       final Lazy<T> lazy = (Lazy<T>) provider;

java/dagger/internal/SetFactory.java

@@ -28,17 +28,18 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
+import org.jspecify.annotations.Nullable;
 
 /**
  * A {@link Factory} implementation used to implement {@link Set} bindings. This factory always
  * returns a new {@link Set} instance for each call to {@link #get} (as required by {@link Factory})
  * whose elements are populated by subsequent calls to their {@link Provider#get} methods.
  */
-public final class SetFactory<T> implements Factory<Set<T>> {
+public final class SetFactory<T extends @Nullable Object> implements Factory<Set<T>> {
   private static final Factory<Set<Object>> EMPTY_FACTORY = InstanceFactory.create(emptySet());
 
   @SuppressWarnings({"unchecked", "rawtypes"}) // safe covariant cast
-  public static <T> Factory<Set<T>> empty() {
+  public static <T extends @Nullable Object> Factory<Set<T>> empty() {
     return (Factory) EMPTY_FACTORY;
   }
 
@@ -47,7 +48,8 @@ public static <T> Factory<Set<T>> empty() {
    * individual {@code Provider<T>} and {@code collectionProviderSize} {@code
    * Provider<Collection<T>>} instances.
    */
-  public static <T> Builder<T> builder(int individualProviderSize, int collectionProviderSize) {
+  public static <T extends @Nullable Object> Builder<T> builder(
+      int individualProviderSize, int collectionProviderSize) {
     return new Builder<T>(individualProviderSize, collectionProviderSize);
   }
 
@@ -56,7 +58,7 @@ public static <T> Builder<T> builder(int individualProviderSize, int collectionP
    * These are only intended to be single-use and from within generated code. Do <em>NOT</em> add
    * providers after calling {@link #build()}.
    */
-  public static final class Builder<T> {
+  public static final class Builder<T extends @Nullable Object> {
     private final List<Provider<T>> individualProviders;
     private final List<Provider<Collection<T>>> collectionProviders;
 

java/dagger/internal/codegen/binding/FrameworkField.java

@@ -16,11 +16,15 @@
 
 package dagger.internal.codegen.binding;
 
+import static androidx.room.compiler.codegen.XTypeNameKt.toJavaPoet;
+import static androidx.room.compiler.codegen.XTypeNameKt.toKotlinPoet;
+import static androidx.room.compiler.codegen.compat.XConverters.toXPoet;
 import static androidx.room.compiler.processing.XElementKt.isConstructor;
 import static androidx.room.compiler.processing.XElementKt.isMethod;
 import static androidx.room.compiler.processing.XElementKt.isMethodParameter;
 import static androidx.room.compiler.processing.XElementKt.isTypeElement;
 import static com.google.common.collect.Iterables.getLast;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
 import static dagger.internal.codegen.model.BindingKind.MEMBERS_INJECTOR;
 import static dagger.internal.codegen.xprocessing.XElements.getSimpleName;
 
@@ -30,7 +34,9 @@
 import androidx.room.compiler.processing.XType;
 import com.google.auto.value.AutoValue;
 import com.google.common.base.CaseFormat;
+import com.squareup.javapoet.AnnotationSpec;
 import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.xprocessing.Nullability;
 import java.util.Optional;
 
 /**
@@ -56,7 +62,8 @@ public abstract class FrameworkField {
    * @param type the base type of the field (e.g., {@code Foo}).
    */
   public static FrameworkField create(String fieldName, XClassName frameworkClassName, XType type) {
-    return createInternal(fieldName, frameworkClassName, Optional.of(type));
+    return createInternal(
+        fieldName, frameworkClassName, Optional.of(type), Nullability.NOT_NULLABLE);
   }
 
   /**
@@ -70,7 +77,8 @@ public static FrameworkField forBinding(
     return createInternal(
         bindingName(binding),
         frameworkClassName.orElse(binding.frameworkType().frameworkClassName()),
-        bindingType(binding));
+        bindingType(binding),
+        binding.nullability());
   }
 
   private static String bindingName(ContributionBinding binding) {
@@ -99,13 +107,28 @@ private static Optional<XType> bindingType(ContributionBinding binding) {
   }
 
   private static FrameworkField createInternal(
-      String fieldName, XClassName frameworkClassName, Optional<XType> type) {
+      String fieldName,
+      XClassName frameworkClassName,
+      Optional<XType> type,
+      Nullability nullability) {
+
+    XTypeName fieldType =
+        type.map(XType::asTypeName)
+            .map(
+                typeName ->
+                    toXPoet(
+                        toJavaPoet(typeName)
+                            .annotated(
+                                nullability.typeUseNullableAnnotations().stream()
+                                    .map(AnnotationSpec::builder)
+                                    .map(AnnotationSpec.Builder::build)
+                                    .collect(toImmutableList())),
+                        toKotlinPoet(typeName)))
+            .map(frameworkClassName::parametrizedBy)
+            .orElse(frameworkClassName);
+
     return new AutoValue_FrameworkField(
-        frameworkFieldName(fieldName, frameworkClassName),
-        type.isPresent()
-            ? frameworkClassName.parametrizedBy(type.get().asTypeName())
-            // Use a raw framework classname, e.g. Provider
-            : frameworkClassName);
+        frameworkFieldName(fieldName, frameworkClassName), fieldType);
   }
 
   private static String frameworkFieldName(String fieldName, XClassName frameworkClassName) {

java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java

@@ -127,7 +127,12 @@ public CodeBlock creationExpression() {
     componentShard.addType(
         COMPONENT_PROVISION_FACTORY,
         classBuilder(factoryClassName)
-            .addSuperinterface(daggerProviderOf(keyType))
+            .addSuperinterface(
+                daggerProviderOf(
+                    keyType.annotated(
+                        binding.nullability().typeUseNullableAnnotations().stream()
+                            .map(annotation -> AnnotationSpec.builder(annotation).build())
+                            .collect(toImmutableList()))))
             .addModifiers(PRIVATE, STATIC, FINAL)
             .addField(dependencyClassName, dependency().variableName(), PRIVATE, FINAL)
             .addMethod(

java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java

@@ -144,9 +144,10 @@ private FieldSpec getOrCreateField() {
         FrameworkField.forBinding(
             binding, frameworkInstanceCreationExpression.alternativeFrameworkClass());
 
-    XTypeName fieldType = useRawType
-        ? contributionBindingField.type().getRawTypeName()
-        : contributionBindingField.type();
+    XTypeName fieldType =
+        useRawType
+            ? contributionBindingField.type().getRawTypeName()
+            : contributionBindingField.type();
 
     if (binding.kind() == BindingKind.ASSISTED_INJECTION) {
       // An assisted injection factory doesn't extend Provider, so we reference the generated

java/dagger/internal/codegen/writing/MembersInjectorGenerator.java

@@ -363,8 +363,7 @@ private static ImmutableMap<DependencyRequest, FieldSpec> frameworkFields(
               // framework type for the field.
               boolean useRawFrameworkType =
                   !isTypeAccessibleFrom(
-                      request.key().type().xprocessing(),
-                      membersInjectorTypeName.packageName());
+                      request.key().type().xprocessing(), membersInjectorTypeName.packageName());
               TypeName fieldType =
                   useRawFrameworkType
                       ? toJavaPoet(bindingField.type().getRawTypeName())

java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java

@@ -452,11 +452,12 @@ static FactoryFields create(ProductionBinding binding) {
 
       ImmutableMap.Builder<DependencyRequest, FieldSpec> builder =
           ImmutableMap.builder();
-      generateBindingFieldsForDependencies(binding).forEach(
-          (dependency, field) ->
-              builder.put(
-                  dependency,
-                  createField(toJavaPoet(field.type()), nameSet.getUniqueName(field.name()))));
+      generateBindingFieldsForDependencies(binding)
+          .forEach(
+              (dependency, field) ->
+                  builder.put(
+                      dependency,
+                      createField(toJavaPoet(field.type()), nameSet.getUniqueName(field.name()))));
       return new FactoryFields(binding, moduleField, builder.buildOrThrow());
     }
 

javatests/dagger/internal/codegen/ComponentProcessorTest.java

@@ -46,6 +46,13 @@ public static Collection<Object[]> parameters() {
     return CompilerMode.TEST_PARAMETERS;
   }
 
+  private static final Source NULLABLE =
+      CompilerTests.javaSource(
+          "test.Nullable", // force one-string-per-line format
+          "package test;",
+          "",
+          "public @interface Nullable {}");
+
   private static final TypeSpec GENERATED_INJECT_TYPE =
       TypeSpec.classBuilder("GeneratedInjectType")
           .addMethod(
@@ -776,6 +783,48 @@ public void componentDependency() throws Exception {
             });
   }
 
+  @Test
+  public void componentWithNullableDependency() throws Exception {
+    Source bFile =
+        CompilerTests.javaSource(
+            "test.B",
+            "package test;",
+            "",
+            "import javax.inject.Inject;",
+            "import javax.inject.Provider;",
+            "",
+            "final class B {",
+            "  @Inject B(Provider<String> a) {}",
+            "}");
+    Source nullableStringComponentFile =
+        CompilerTests.javaSource(
+            "test.NullableStringComponent",
+            "package test;",
+            "",
+            "interface NullableStringComponent {",
+            "  @Nullable String nullableString();",
+            "}");
+    Source bComponentFile =
+        CompilerTests.javaSource(
+            "test.BComponent",
+            "package test;",
+            "",
+            "import dagger.Component;",
+            "",
+            "@Component(dependencies = NullableStringComponent.class)",
+            "interface BComponent {",
+            "  B b();",
+            "}");
+
+    CompilerTests.daggerCompiler(nullableStringComponentFile, bFile, bComponentFile, NULLABLE)
+        .withProcessingOptions(compilerMode.processorOptions())
+        .compile(
+            subject -> {
+              subject.hasErrorCount(0);
+              subject.generatedSource(goldenFileRule.goldenSource("test/DaggerBComponent"));
+            });
+  }
+
   @Test
   public void primitiveComponentDependency() throws Exception {
     Source bFile = CompilerTests.javaSource("test.B",

javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithNullableDependency_DEFAULT_MODE_test.DaggerBComponent

@@ -0,0 +1,82 @@
+package test;
+    
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Preconditions;
+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 DaggerBComponent {
+  private DaggerBComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  static final class Builder {
+    private NullableStringComponent nullableStringComponent;
+
+    private Builder() {
+    }
+
+    public Builder nullableStringComponent(NullableStringComponent nullableStringComponent) {
+      this.nullableStringComponent = Preconditions.checkNotNull(nullableStringComponent);
+      return this;
+    }
+
+    public BComponent build() {
+      Preconditions.checkBuilderRequirement(nullableStringComponent, NullableStringComponent.class);
+      return new BComponentImpl(nullableStringComponent);
+    }
+  }
+
+  private static final class BComponentImpl implements BComponent {
+    private final BComponentImpl bComponentImpl = this;
+
+    private Provider<String> nullableStringProvider;
+
+    private BComponentImpl(NullableStringComponent nullableStringComponentParam) {
+
+      initialize(nullableStringComponentParam);
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize(final NullableStringComponent nullableStringComponentParam) {
+      this.nullableStringProvider = new NullableStringProvider(nullableStringComponentParam);
+    }
+
+    @Override
+    public B b() {
+      return new B(nullableStringProvider);
+    }
+
+    private static final class NullableStringProvider implements Provider<String> {
+      private final NullableStringComponent nullableStringComponent;
+
+      NullableStringProvider(NullableStringComponent nullableStringComponent) {
+        this.nullableStringComponent = nullableStringComponent;
+      }
+
+      @Override
+      @Nullable
+      public String get() {
+        return nullableStringComponent.nullableString();
+      }
+    }
+  }
+}