Support prunable hilt entry points.

Added `@OnlyUsedBy(\*binding identifiers*\)` to be used on entry points that indicates an entry point should be pruned if no usage of it is found. An entry point is considered as unused if:
1. No corresponding binding identifier is found. A binding's default identifier is its enclosing class, user may also explicitly specify a identifier using `@BindingIdentifier` on the binding element.

1. The entry point is only being used by a binding that is unused, which will not present in the pruned graph.

RELNOTES=Support prunable hilt entry points.
PiperOrigin-RevId: 640960016

Author: wanyingd1996

java/dagger/internal/codegen/binding/BindingGraph.java

@@ -74,7 +74,8 @@ public abstract class BindingGraph {
   public abstract static class TopLevelBindingGraph
       extends dagger.internal.codegen.model.BindingGraph {
     static TopLevelBindingGraph create(
-        ImmutableNetwork<Node, Edge> network, boolean isFullBindingGraph) {
+        ImmutableNetwork<Node, Edge> network,
+        boolean isFullBindingGraph) {
       TopLevelBindingGraph topLevelBindingGraph =
           new AutoValue_BindingGraph_TopLevelBindingGraph(network, isFullBindingGraph);
 

java/dagger/internal/codegen/binding/BindingGraphConverter.java

@@ -77,7 +77,9 @@ BindingGraph convert(LegacyBindingGraph legacyBindingGraph, boolean isFullBindin
     }
 
     TopLevelBindingGraph topLevelBindingGraph =
-        TopLevelBindingGraph.create(ImmutableNetwork.copyOf(network), isFullBindingGraph);
+        TopLevelBindingGraph.create(
+            ImmutableNetwork.copyOf(network),
+            isFullBindingGraph);
     return BindingGraph.create(rootNode, topLevelBindingGraph);
   }
 
@@ -122,8 +124,7 @@ private void visitComponent(LegacyBindingGraph graph) {
 
       network.addNode(graph.componentNode());
 
-      for (ComponentMethodDescriptor entryPointMethod :
-          graph.componentDescriptor().entryPointMethods()) {
+      for (ComponentMethodDescriptor entryPointMethod : graph.entryPointMethods()) {
         addDependencyEdges(graph.componentNode(), entryPointMethod.dependencyRequest().get());
       }
 

java/dagger/internal/codegen/binding/BindingGraphFactory.java

@@ -22,6 +22,7 @@
 import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
 import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.isAssistedFactoryType;
 import static dagger.internal.codegen.binding.SourceFiles.generatedMonitoringModuleName;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
 import static dagger.internal.codegen.model.BindingKind.ASSISTED_INJECTION;
 import static dagger.internal.codegen.model.BindingKind.DELEGATE;
 import static dagger.internal.codegen.model.BindingKind.INJECTION;
@@ -48,6 +49,7 @@
 import dagger.internal.codegen.base.Keys;
 import dagger.internal.codegen.base.MapType;
 import dagger.internal.codegen.base.OptionalType;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
 import dagger.internal.codegen.compileroption.CompilerOptions;
 import dagger.internal.codegen.javapoet.TypeNames;
 import dagger.internal.codegen.model.BindingGraph.ComponentNode;
@@ -212,14 +214,7 @@ private LegacyBindingGraph createLegacyBindingGraph(
 
     componentDescriptor.entryPointMethods().stream()
         .map(method -> method.dependencyRequest().get())
-        .forEach(
-            entryPoint -> {
-              if (entryPoint.kind().equals(MEMBERS_INJECTION)) {
-                requestResolver.resolveMembersInjection(entryPoint.key());
-              } else {
-                requestResolver.resolve(entryPoint.key());
-              }
-            });
+        .forEach(entryPoint -> resolveEntryPointsHelper(entryPoint, requestResolver));
 
     if (createFullBindingGraph) {
       // Resolve the keys for all bindings in all modules, stripping any multibinding contribution
@@ -249,6 +244,14 @@ private LegacyBindingGraph createLegacyBindingGraph(
     return new LegacyBindingGraph(requestResolver, subgraphs.build());
   }
 
+  private void resolveEntryPointsHelper(DependencyRequest entryPoint, Resolver requestResolver) {
+    if (entryPoint.kind().equals(MEMBERS_INJECTION)) {
+      requestResolver.resolveMembersInjection(entryPoint.key());
+    } else {
+      requestResolver.resolve(entryPoint.key());
+    }
+  }
+
   /**
    * Returns all the modules that should be installed in the component. For production components
    * and production subcomponents that have a parent that is not a production component or
@@ -296,7 +299,7 @@ static final class LegacyBindingGraph {
     private final ImmutableList<LegacyBindingGraph> resolvedSubgraphs;
     private final ComponentNode componentNode;
 
-    LegacyBindingGraph(Resolver resolver, ImmutableList<LegacyBindingGraph> resolvedSubgraphs) {
+        LegacyBindingGraph(Resolver resolver, ImmutableList<LegacyBindingGraph> resolvedSubgraphs) {
       this.resolver = resolver;
       this.resolvedSubgraphs = resolvedSubgraphs;
       this.componentNode =
@@ -318,6 +321,11 @@ ComponentDescriptor componentDescriptor() {
       return resolver.componentDescriptor;
     }
 
+    ImmutableList<ComponentMethodDescriptor> entryPointMethods() {
+      return componentDescriptor().entryPointMethods().stream()
+          .collect(toImmutableList());
+    }
+
     /**
      * Returns the {@link ResolvedBindings} in this graph or a parent graph that matches the given
      * request.

java/dagger/internal/codegen/writing/ComponentImplementation.java

@@ -59,7 +59,6 @@
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.MultimapBuilder;
-import com.google.common.collect.Sets;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.CodeBlock;
 import com.squareup.javapoet.FieldSpec;
@@ -97,7 +96,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 import javax.inject.Inject;
 import javax.inject.Provider;
 import javax.lang.model.element.Modifier;
@@ -886,14 +884,19 @@ private void addInterfaceMethods() {
       // Each component method may have been declared by several supertypes. We want to implement
       // only one method for each distinct signature.
       XType componentType = graph.componentTypeElement().getType();
-      Set<MethodSignature> signatures = Sets.newHashSet();
+      Map<MethodSignature, ComponentMethodDescriptor> methodDescriptors = new LinkedHashMap<>();
       for (ComponentMethodDescriptor method : graph.componentDescriptor().entryPointMethods()) {
-        if (signatures.add(
-            MethodSignature.forComponentMethod(method, componentType, processingEnv))) {
+        MethodSignature signature =
+            MethodSignature.forComponentMethod(method, componentType, processingEnv);
+        if (!methodDescriptors.containsKey(signature)) {
+          methodDescriptors.put(signature, method);
+        }
+      }
+
+      for (ComponentMethodDescriptor method : methodDescriptors.values()) {
           addMethod(
               COMPONENT_METHOD,
               componentRequestRepresentationsProvider.get().getComponentMethod(method));
-        }
       }
     }
 

javatests/dagger/internal/codegen/goldens/UnusedEntryPointTest_entryPointInUse_implicitBindingIdentifier_generatesEntryPointImplementation_DEFAULT_MODE_test.DaggerMyComponent

@@ -0,0 +1,59 @@
+package test;
+
+import dagger.internal.DaggerGenerated;
+import javax.annotation.processing.Generated;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+final class DaggerMyComponent {
+  private DaggerMyComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static MyComponent create() {
+    return new Builder().build();
+  }
+
+  static final class Builder {
+    private Builder() {
+    }
+
+    public MyComponent build() {
+      return new MyComponentImpl();
+    }
+  }
+
+  private static final class MyComponentImpl implements MyComponent {
+    private final MyComponentImpl myComponentImpl = this;
+
+    private MyComponentImpl() {
+
+
+    }
+
+    @Override
+    public Bar getBar() {
+      return new Bar();
+    }
+
+    @Override
+    public Foo getFoo() {
+      return new Foo();
+    }
+  }
+}
+

javatests/dagger/internal/codegen/goldens/UnusedEntryPointTest_entryPointInUse_implicitBindingIdentifier_generatesEntryPointImplementation_FAST_INIT_MODE_test.DaggerMyComponent

@@ -0,0 +1,59 @@
+package test;
+
+import dagger.internal.DaggerGenerated;
+import javax.annotation.processing.Generated;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+final class DaggerMyComponent {
+  private DaggerMyComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static MyComponent create() {
+    return new Builder().build();
+  }
+
+  static final class Builder {
+    private Builder() {
+    }
+
+    public MyComponent build() {
+      return new MyComponentImpl();
+    }
+  }
+
+  private static final class MyComponentImpl implements MyComponent {
+    private final MyComponentImpl myComponentImpl = this;
+
+    private MyComponentImpl() {
+
+
+    }
+
+    @Override
+    public Bar getBar() {
+      return new Bar();
+    }
+
+    @Override
+    public Foo getFoo() {
+      return new Foo();
+    }
+  }
+}
+

javatests/dagger/internal/codegen/goldens/UnusedEntryPointTest_entryPointInUse_implicitModuleBindingIdentifier_generatesEntryPointImplementation_DEFAULT_MODE_test.DaggerMyComponent

@@ -0,0 +1,72 @@
+package test;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Preconditions;
+import javax.annotation.processing.Generated;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation"
+})
+final class DaggerMyComponent {
+  private DaggerMyComponent() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static MyComponent create() {
+    return new Builder().build();
+  }
+
+  static final class Builder {
+    private FooModule fooModule;
+
+    private Builder() {
+    }
+
+    public Builder fooModule(FooModule fooModule) {
+      this.fooModule = Preconditions.checkNotNull(fooModule);
+      return this;
+    }
+
+    public MyComponent build() {
+      if (fooModule == null) {
+        this.fooModule = new FooModule();
+      }
+      return new MyComponentImpl(fooModule);
+    }
+  }
+
+  private static final class MyComponentImpl implements MyComponent {
+    private final FooModule fooModule;
+
+    private final MyComponentImpl myComponentImpl = this;
+
+    private MyComponentImpl(FooModule fooModuleParam) {
+      this.fooModule = fooModuleParam;
+
+    }
+
+    @Override
+    public Bar getBar() {
+      throw new UnsupportedOperationException("This entry point is pruned because it has been marked as unused, please update @OnlyUsedBy to reflect its usage.");
+    }
+
+    @Override
+    public Foo getFoo() {
+      return FooModule_ProvidesFooFactory.providesFoo(fooModule);
+    }
+  }
+}
+