Internal changes

RELNOTES=N/A
PiperOrigin-RevId: 588861836

java/dagger/internal/codegen/base/TarjanSCCs.java

@@ -20,6 +20,7 @@
 import static java.lang.Math.min;
 
 import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
@@ -39,7 +40,7 @@
 public final class TarjanSCCs {
 
  /** Returns the set of strongly connected components in reverse topological order. */
- public static <NodeT> ImmutableSet<ImmutableSet<NodeT>> compute(
+ public static <NodeT> ImmutableList<ImmutableSet<NodeT>> compute(
  ImmutableCollection<NodeT> nodes, SuccessorsFunction<NodeT> successorsFunction) {
  return new TarjanSCC<>(nodes, successorsFunction).compute();
  }
@@ -62,14 +63,14 @@ private static class TarjanSCC<NodeT> {
  this.lowLinks = Maps.newHashMapWithExpectedSize(nodes.size());
  }
 
- private ImmutableSet<ImmutableSet<NodeT>> compute() {
+ private ImmutableList<ImmutableSet<NodeT>> compute() {
  checkState(indexes.isEmpty(), "TarjanSCC#compute() can only be called once per instance!");
  for (NodeT node : nodes) {
  if (!indexes.containsKey(node)) {
  stronglyConnect(node);
  }
  }
- return ImmutableSet.copyOf(stronglyConnectedComponents);
+ return ImmutableList.copyOf(stronglyConnectedComponents);
  }
 
  private void stronglyConnect(NodeT node) {

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

@@ -149,7 +149,7 @@ Comparator<Node> nodeOrder() {
 
  /** Returns the set of strongly connected nodes in this graph in reverse topological order. */
  @Memoized
- public ImmutableSet<ImmutableSet<Node>> stronglyConnectedNodes() {
+ public ImmutableList<ImmutableSet<Node>> stronglyConnectedNodes() {
  return TarjanSCCs.<Node>compute(
  ImmutableSet.copyOf(network().nodes()),
  // NetworkBuilder does not have a stable successor order, so we have to roll our own

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

@@ -648,8 +648,7 @@ private ContributionBinding createDelegateBinding(DelegateDeclaration delegateDe
  * ResolvedBindings#owningComponent(ContributionBinding)}.
  */
  private XTypeElement getOwningComponent(Key requestKey, ContributionBinding binding) {
- if (isResolvedInParent(requestKey, binding)
- && !new RequiresResolutionChecker().requiresResolution(binding)) {
+ if (isResolvedInParent(requestKey, binding) && !requiresResolution(binding)) {
  ResolvedBindings parentResolvedBindings =
  parentResolver.get().resolvedContributionBindings.get(requestKey);
  return parentResolvedBindings.owningComponent(binding);
@@ -876,7 +875,7 @@ void resolve(Key key) {
  previouslyResolvedBindings.bindings().stream()
  .anyMatch(binding -> binding.kind() == BindingKind.ASSISTED_INJECTION);
  if (!isAssistedInjectionBinding
- && !new RequiresResolutionChecker().requiresResolution(key)
+ && !requiresResolution(key)
  && getLocalExplicitBindings(key).isEmpty()) {
  /* Cache the inherited parent component's bindings in case resolving at the parent found
  * bindings in some component between this one and the previously-resolved one. */
@@ -921,7 +920,15 @@ private ResolvedBindings getResolvedMembersInjectionBindings(Key key) {
  return resolvedMembersInjectionBindings.get(key);
  }
 
- private final class RequiresResolutionChecker {
+ private boolean requiresResolution(Key key) {
+ return new LegacyRequiresResolutionChecker().requiresResolution(key);
+ }
+
+ private boolean requiresResolution(Binding binding) {
+ return new LegacyRequiresResolutionChecker().requiresResolution(binding);
+ }
+
+ private final class LegacyRequiresResolutionChecker {
  private final Set<Object> cycleChecker = new HashSet<>();
 
  /**
@@ -969,9 +976,7 @@ private boolean requiresResolutionUncached(Key key) {
  Resolver.this,
  key);
  ResolvedBindings previouslyResolvedBindings = getPreviouslyResolvedBindings(key).get();
- if (hasLocalMultibindingContributions(key)
- || hasLocalOptionalBindingContribution(previouslyResolvedBindings)
- ) {
+ if (hasLocalBindings(previouslyResolvedBindings)) {
  return true;
  }
 
@@ -995,35 +1000,50 @@ private boolean requiresResolutionUncached(Binding binding) {
  }
  return false;
  }
+ }
 
- /**
- * Returns {@code true} if there is at least one multibinding contribution declared within
- * this component's modules that matches the key.
- */
- private boolean hasLocalMultibindingContributions(Key requestKey) {
- return keysMatchingRequest(requestKey)
- .stream()
- .anyMatch(key -> !getLocalExplicitMultibindings(key).isEmpty());
- }
+ private boolean hasLocalBindings(Binding binding) {
+ return hasLocalMultibindingContributions(binding.key())
+ || hasLocalOptionalBindingContribution(
+ binding.key(), ImmutableSet.of((ContributionBinding) binding));
+ }
 
- /**
- * Returns {@code true} if there is a contribution in this component for an {@code
- * Optional<Foo>} key that has not been contributed in a parent.
- */
- private boolean hasLocalOptionalBindingContribution(ResolvedBindings resolvedBindings) {
- if (resolvedBindings
- .contributionBindings()
- .stream()
- .map(ContributionBinding::kind)
- .anyMatch(isEqual(OPTIONAL))) {
- return !getLocalExplicitBindings(keyFactory.unwrapOptional(resolvedBindings.key()).get())
- .isEmpty();
- } else {
- // If a parent contributes a @Provides Optional<Foo> binding and a child has a
- // @BindsOptionalOf Foo method, the two should conflict, even if there is no binding for
- // Foo on its own
- return !getOptionalBindingDeclarations(resolvedBindings.key()).isEmpty();
- }
+ private boolean hasLocalBindings(ResolvedBindings resolvedBindings) {
+ return hasLocalMultibindingContributions(resolvedBindings.key())
+ || hasLocalOptionalBindingContribution(resolvedBindings);
+ }
+
+ /**
+ * Returns {@code true} if there is at least one multibinding contribution declared within
+ * this component's modules that matches the key.
+ */
+ private boolean hasLocalMultibindingContributions(Key requestKey) {
+ return keysMatchingRequest(requestKey)
+ .stream()
+ .anyMatch(key -> !getLocalExplicitMultibindings(key).isEmpty());
+ }
+
+ /**
+ * Returns {@code true} if there is a contribution in this component for an {@code
+ * Optional<Foo>} key that has not been contributed in a parent.
+ */
+ private boolean hasLocalOptionalBindingContribution(ResolvedBindings resolvedBindings) {
+ return hasLocalOptionalBindingContribution(
+ resolvedBindings.key(), resolvedBindings.contributionBindings());
+ }
+
+ private boolean hasLocalOptionalBindingContribution(
+ Key key, ImmutableSet<ContributionBinding> previousContributionBindings) {
+ if (previousContributionBindings.stream()
+ .map(ContributionBinding::kind)
+ .anyMatch(isEqual(OPTIONAL))) {
+ return !getLocalExplicitBindings(keyFactory.unwrapOptional(key).get())
+ .isEmpty();
+ } else {
+ // If a parent contributes a @Provides Optional<Foo> binding and a child has a
+ // @BindsOptionalOf Foo method, the two should conflict, even if there is no binding for
+ // Foo on its own
+ return !getOptionalBindingDeclarations(key).isEmpty();
  }
  }
  }