Change the Binding class hierarchy to reflect BindingKind rather than BindingType.

This change is necessary to decouple the `BindingType` from the binding class hierarchy, which currently prevents us from creating a binding without already having access to its dependencies.

RELNOTES=N/A
PiperOrigin-RevId: 649081259

Author: bcorso

java/dagger/internal/codegen/DelegateComponentProcessor.java

@@ -35,12 +35,12 @@
 import dagger.internal.codegen.base.SourceFileHjarGenerator;
 import dagger.internal.codegen.binding.BindingGraphFactory;
 import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ContributionBinding;
 import dagger.internal.codegen.binding.InjectBindingRegistry;
 import dagger.internal.codegen.binding.MembersInjectionBinding;
 import dagger.internal.codegen.binding.ModuleDescriptor;
 import dagger.internal.codegen.binding.MonitoringModules;
 import dagger.internal.codegen.binding.ProductionBinding;
-import dagger.internal.codegen.binding.ProvisionBinding;
 import dagger.internal.codegen.bindinggraphvalidation.BindingGraphValidationModule;
 import dagger.internal.codegen.compileroption.CompilerOptions;
 import dagger.internal.codegen.componentgenerator.ComponentGeneratorModule;
@@ -74,7 +74,7 @@ final class DelegateComponentProcessor {
       new XProcessingEnvConfig.Builder().disableAnnotatedElementValidation(true).build();
 
   @Inject InjectBindingRegistry injectBindingRegistry;
-  @Inject SourceFileGenerator<ProvisionBinding> factoryGenerator;
+  @Inject SourceFileGenerator<ContributionBinding> factoryGenerator;
   @Inject SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator;
   @Inject ImmutableList<XProcessingStep> processingSteps;
   @Inject ValidationBindingGraphPlugins validationBindingGraphPlugins;
@@ -204,7 +204,7 @@ interface ProcessingRoundCacheModule {
   @Module
   interface SourceFileGeneratorsModule {
     @Provides
-    static SourceFileGenerator<ProvisionBinding> factoryGenerator(
+    static SourceFileGenerator<ContributionBinding> factoryGenerator(
         FactoryGenerator generator,
         CompilerOptions compilerOptions,
         XProcessingEnv processingEnv) {

java/dagger/internal/codegen/binding/AssistedFactoryBinding.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2024 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.CheckReturnValue;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.model.BindingKind;
+import dagger.internal.codegen.model.DependencyRequest;
+import dagger.internal.codegen.model.Key;
+import dagger.internal.codegen.model.RequestKind;
+
+/** A binding for a {@link BindingKind#ASSISTED_FACTORY}. */
+@CheckReturnValue
+@AutoValue
+public abstract class AssistedFactoryBinding extends ContributionBinding {
+  @Override
+  public BindingKind kind() {
+    return BindingKind.ASSISTED_FACTORY;
+  }
+
+  @Override
+  public BindingType bindingType() {
+    return BindingType.PROVISION;
+  }
+
+  @Override
+  public ContributionType contributionType() {
+    return ContributionType.UNIQUE;
+  }
+
+  @Override
+  public Nullability nullability() {
+    return Nullability.NOT_NULLABLE;
+  }
+
+  @Override
+  @Memoized
+  public ImmutableSet<DependencyRequest> dependencies() {
+    return ImmutableSet.of(
+        DependencyRequest.builder()
+            .key(assistedInjectKey())
+            .kind(RequestKind.PROVIDER)
+            .build());
+  }
+
+  /** Returns the key for the associated {@code @AssistedInject} binding. */
+  public abstract Key assistedInjectKey();
+
+  @Override
+  public abstract Builder toBuilder();
+
+  @Memoized
+  @Override
+  public abstract int hashCode();
+
+  // TODO(ronshapiro,dpb): simplify the equality semantics
+  @Override
+  public abstract boolean equals(Object obj);
+
+  static Builder builder() {
+    return new AutoValue_AssistedFactoryBinding.Builder();
+  }
+
+  /** A {@link AssistedFactoryBinding} builder. */
+  @AutoValue.Builder
+  abstract static class Builder
+      extends ContributionBinding.Builder<AssistedFactoryBinding, Builder> {
+    abstract Builder assistedInjectKey(Key assistedInjectKey);
+  }
+}

java/dagger/internal/codegen/binding/AssistedInjectionBinding.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2024 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.errorprone.annotations.CheckReturnValue;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.model.BindingKind;
+import dagger.internal.codegen.model.DependencyRequest;
+
+/** A binding for a {@link BindingKind#ASSISTED_INJECTION}. */
+@CheckReturnValue
+@AutoValue
+public abstract class AssistedInjectionBinding extends ContributionBinding {
+  @Override
+  public BindingKind kind() {
+    return BindingKind.ASSISTED_INJECTION;
+  }
+
+  @Override
+  public BindingType bindingType() {
+    return BindingType.PROVISION;
+  }
+
+  @Override
+  public ContributionType contributionType() {
+    return ContributionType.UNIQUE;
+  }
+
+  @Override
+  public Nullability nullability() {
+    return Nullability.NOT_NULLABLE;
+  }
+
+  /** Dependencies necessary to invoke the {@code @Inject} annotated constructor. */
+  public abstract ImmutableSet<DependencyRequest> constructorDependencies();
+
+  /** {@link InjectionSite}s for all {@code @Inject} members. */
+  public abstract ImmutableSortedSet<InjectionSite> injectionSites();
+
+  @Override
+  @Memoized
+  public ImmutableSet<DependencyRequest> dependencies() {
+    return ImmutableSet.<DependencyRequest>builder()
+        .addAll(constructorDependencies())
+        .addAll(
+            injectionSites().stream()
+                .flatMap(i -> i.dependencies().stream())
+                .collect(toImmutableSet()))
+        .build();
+  }
+
+  @Override
+  public abstract Builder toBuilder();
+
+  @Memoized
+  @Override
+  public abstract int hashCode();
+
+  // TODO(ronshapiro,dpb): simplify the equality semantics
+  @Override
+  public abstract boolean equals(Object obj);
+
+  static Builder builder() {
+    return new AutoValue_AssistedInjectionBinding.Builder();
+  }
+
+  /** A {@link AssistedInjectionBinding} builder. */
+  @AutoValue.Builder
+  abstract static class Builder
+      extends ContributionBinding.Builder<AssistedInjectionBinding, Builder> {
+    abstract Builder constructorDependencies(Iterable<DependencyRequest> constructorDependencies);
+
+    abstract Builder injectionSites(ImmutableSortedSet<InjectionSite> injectionSites);
+  }
+}

java/dagger/internal/codegen/binding/Binding.java

@@ -16,13 +16,7 @@
 
 package dagger.internal.codegen.binding;
 
-import static com.google.common.base.Suppliers.memoize;
-import static dagger.internal.codegen.xprocessing.XElements.isAbstract;
-import static dagger.internal.codegen.xprocessing.XElements.isStatic;
-
-import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
 import dagger.internal.codegen.model.BindingKind;
 import dagger.internal.codegen.model.DependencyRequest;
 import dagger.internal.codegen.model.Scope;
@@ -40,12 +34,7 @@ public abstract class Binding extends BindingDeclaration {
    * Returns {@code true} if using this binding requires an instance of the {@link
    * #contributingModule()}.
    */
-  public boolean requiresModuleInstance() {
-    return contributingModule().isPresent()
-        && bindingElement().isPresent()
-        && !isAbstract(bindingElement().get())
-        && !isStatic(bindingElement().get());
-  }
+  public abstract boolean requiresModuleInstance();
 
   /**
    * Returns {@code true} if this binding may provide {@code null} instead of an instance of {@link
@@ -65,38 +54,8 @@ public final FrameworkType frameworkType() {
     return FrameworkType.forBindingType(bindingType());
   }
 
-  /**
-   * The explicit set of {@link DependencyRequest dependencies} required to satisfy this binding as
-   * defined by the user-defined injection sites.
-   */
-  public abstract ImmutableSet<DependencyRequest> explicitDependencies();
-
-  /**
-   * The set of {@link DependencyRequest dependencies} that are added by the framework rather than a
-   * user-defined injection site. This returns an unmodifiable set.
-   */
-  public ImmutableSet<DependencyRequest> implicitDependencies() {
-    return ImmutableSet.of();
-  }
-
-  private final Supplier<ImmutableSet<DependencyRequest>> dependencies =
-      memoize(
-          () -> {
-            ImmutableSet<DependencyRequest> implicitDependencies = implicitDependencies();
-            return ImmutableSet.copyOf(
-                implicitDependencies.isEmpty()
-                    ? explicitDependencies()
-                    : Sets.union(implicitDependencies, explicitDependencies()));
-          });
-
-  /**
-   * The set of {@link DependencyRequest dependencies} required to satisfy this binding. This is the
-   * union of {@link #explicitDependencies()} and {@link #implicitDependencies()}. This returns an
-   * unmodifiable set.
-   */
-  public final ImmutableSet<DependencyRequest> dependencies() {
-    return dependencies.get();
-  }
+  /** The set of {@link DependencyRequest dependencies} required to satisfy this binding. */
+  public abstract ImmutableSet<DependencyRequest> dependencies();
 
   /**
    * If this binding's key's type parameters are different from those of the {@link
@@ -105,7 +64,6 @@ public final ImmutableSet<DependencyRequest> dependencies() {
    */
   public abstract Optional<? extends Binding> unresolved();
 
-  public Optional<Scope> scope() {
-    return Optional.empty();
-  }
+  /** Returns the optional scope used on the binding. */
+  public abstract Optional<Scope> scope();
 }