579 lines
25 KiB
Java
579 lines
25 KiB
Java
/*
|
|
* Copyright (C) 2017 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 com.google.auto.common.MoreElements.isAnnotationPresent;
|
|
import static com.google.auto.common.MoreTypes.asDeclared;
|
|
import static com.google.common.base.Preconditions.checkArgument;
|
|
import static com.google.common.base.Preconditions.checkNotNull;
|
|
import static com.google.common.base.Preconditions.checkState;
|
|
import static com.google.common.collect.Iterables.getOnlyElement;
|
|
import static dagger.internal.codegen.base.MoreAnnotationMirrors.wrapOptionalInEquivalence;
|
|
import static dagger.internal.codegen.base.Scopes.uniqueScopeOf;
|
|
import static dagger.internal.codegen.binding.Binding.hasNonDefaultTypeParameters;
|
|
import static dagger.internal.codegen.binding.ComponentDescriptor.isComponentProductionMethod;
|
|
import static dagger.internal.codegen.binding.ConfigurationAnnotations.getNullableType;
|
|
import static dagger.internal.codegen.binding.ContributionBinding.bindingKindForMultibindingKey;
|
|
import static dagger.internal.codegen.binding.MapKeys.getMapKey;
|
|
import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
|
|
import static dagger.model.BindingKind.ASSISTED_FACTORY;
|
|
import static dagger.model.BindingKind.ASSISTED_INJECTION;
|
|
import static dagger.model.BindingKind.BOUND_INSTANCE;
|
|
import static dagger.model.BindingKind.COMPONENT;
|
|
import static dagger.model.BindingKind.COMPONENT_DEPENDENCY;
|
|
import static dagger.model.BindingKind.COMPONENT_PRODUCTION;
|
|
import static dagger.model.BindingKind.COMPONENT_PROVISION;
|
|
import static dagger.model.BindingKind.DELEGATE;
|
|
import static dagger.model.BindingKind.INJECTION;
|
|
import static dagger.model.BindingKind.MEMBERS_INJECTOR;
|
|
import static dagger.model.BindingKind.OPTIONAL;
|
|
import static dagger.model.BindingKind.PRODUCTION;
|
|
import static dagger.model.BindingKind.PROVISION;
|
|
import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
|
|
import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
|
|
import static javax.lang.model.element.ElementKind.METHOD;
|
|
|
|
import com.google.auto.common.MoreElements;
|
|
import com.google.auto.common.MoreTypes;
|
|
import com.google.common.collect.ImmutableCollection;
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.google.common.collect.ImmutableSortedSet;
|
|
import com.google.common.collect.Iterables;
|
|
import dagger.Module;
|
|
import dagger.assisted.AssistedInject;
|
|
import dagger.internal.codegen.base.ContributionType;
|
|
import dagger.internal.codegen.base.MapType;
|
|
import dagger.internal.codegen.base.SetType;
|
|
import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
|
|
import dagger.internal.codegen.binding.ProductionBinding.ProductionKind;
|
|
import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
|
|
import dagger.internal.codegen.langmodel.DaggerElements;
|
|
import dagger.internal.codegen.langmodel.DaggerTypes;
|
|
import dagger.model.DependencyRequest;
|
|
import dagger.model.Key;
|
|
import dagger.model.RequestKind;
|
|
import dagger.producers.Produced;
|
|
import dagger.producers.Producer;
|
|
import java.util.Optional;
|
|
import java.util.function.BiFunction;
|
|
import javax.inject.Inject;
|
|
import javax.inject.Provider;
|
|
import javax.lang.model.element.Element;
|
|
import javax.lang.model.element.ExecutableElement;
|
|
import javax.lang.model.element.TypeElement;
|
|
import javax.lang.model.element.VariableElement;
|
|
import javax.lang.model.type.DeclaredType;
|
|
import javax.lang.model.type.ExecutableType;
|
|
import javax.lang.model.type.TypeMirror;
|
|
|
|
/** A factory for {@link Binding} objects. */
|
|
public final class BindingFactory {
|
|
private final DaggerTypes types;
|
|
private final KeyFactory keyFactory;
|
|
private final DependencyRequestFactory dependencyRequestFactory;
|
|
private final InjectionSiteFactory injectionSiteFactory;
|
|
private final DaggerElements elements;
|
|
private final InjectionAnnotations injectionAnnotations;
|
|
private final KotlinMetadataUtil metadataUtil;
|
|
|
|
@Inject
|
|
BindingFactory(
|
|
DaggerTypes types,
|
|
DaggerElements elements,
|
|
KeyFactory keyFactory,
|
|
DependencyRequestFactory dependencyRequestFactory,
|
|
InjectionSiteFactory injectionSiteFactory,
|
|
InjectionAnnotations injectionAnnotations,
|
|
KotlinMetadataUtil metadataUtil) {
|
|
this.types = types;
|
|
this.elements = elements;
|
|
this.keyFactory = keyFactory;
|
|
this.dependencyRequestFactory = dependencyRequestFactory;
|
|
this.injectionSiteFactory = injectionSiteFactory;
|
|
this.injectionAnnotations = injectionAnnotations;
|
|
this.metadataUtil = metadataUtil;
|
|
}
|
|
|
|
/**
|
|
* Returns an {@link dagger.model.BindingKind#INJECTION} binding.
|
|
*
|
|
* @param constructorElement the {@code @Inject}-annotated constructor
|
|
* @param resolvedType the parameterized type if the constructor is for a generic class and the
|
|
* binding should be for the parameterized type
|
|
*/
|
|
// TODO(dpb): See if we can just pass the parameterized type and not also the constructor.
|
|
public ProvisionBinding injectionBinding(
|
|
ExecutableElement constructorElement, Optional<TypeMirror> resolvedType) {
|
|
checkArgument(constructorElement.getKind().equals(CONSTRUCTOR));
|
|
checkArgument(
|
|
isAnnotationPresent(constructorElement, Inject.class)
|
|
|| isAnnotationPresent(constructorElement, AssistedInject.class));
|
|
checkArgument(!injectionAnnotations.getQualifier(constructorElement).isPresent());
|
|
|
|
ExecutableType constructorType = MoreTypes.asExecutable(constructorElement.asType());
|
|
DeclaredType constructedType =
|
|
MoreTypes.asDeclared(constructorElement.getEnclosingElement().asType());
|
|
// If the class this is constructing has some type arguments, resolve everything.
|
|
if (!constructedType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
|
|
DeclaredType resolved = MoreTypes.asDeclared(resolvedType.get());
|
|
// Validate that we're resolving from the correct type.
|
|
checkState(
|
|
types.isSameType(types.erasure(resolved), types.erasure(constructedType)),
|
|
"erased expected type: %s, erased actual type: %s",
|
|
types.erasure(resolved),
|
|
types.erasure(constructedType));
|
|
constructorType = MoreTypes.asExecutable(types.asMemberOf(resolved, constructorElement));
|
|
constructedType = resolved;
|
|
}
|
|
|
|
// Collect all dependency requests within the provision method.
|
|
// Note: we filter out @Assisted parameters since these aren't considered dependency requests.
|
|
ImmutableSet.Builder<DependencyRequest> provisionDependencies = ImmutableSet.builder();
|
|
for (int i = 0; i < constructorElement.getParameters().size(); i++) {
|
|
VariableElement parameter = constructorElement.getParameters().get(i);
|
|
TypeMirror parameterType = constructorType.getParameterTypes().get(i);
|
|
if (!AssistedInjectionAnnotations.isAssistedParameter(parameter)) {
|
|
provisionDependencies.add(
|
|
dependencyRequestFactory.forRequiredResolvedVariable(parameter, parameterType));
|
|
}
|
|
}
|
|
|
|
Key key = keyFactory.forInjectConstructorWithResolvedType(constructedType);
|
|
ProvisionBinding.Builder builder =
|
|
ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.bindingElement(constructorElement)
|
|
.key(key)
|
|
.provisionDependencies(provisionDependencies.build())
|
|
.injectionSites(injectionSiteFactory.getInjectionSites(constructedType))
|
|
.kind(
|
|
isAnnotationPresent(constructorElement, AssistedInject.class)
|
|
? ASSISTED_INJECTION
|
|
: INJECTION)
|
|
.scope(uniqueScopeOf(constructorElement.getEnclosingElement()));
|
|
|
|
TypeElement bindingTypeElement = MoreElements.asType(constructorElement.getEnclosingElement());
|
|
if (hasNonDefaultTypeParameters(bindingTypeElement, key.type(), types)) {
|
|
builder.unresolved(injectionBinding(constructorElement, Optional.empty()));
|
|
}
|
|
return builder.build();
|
|
}
|
|
|
|
public ProvisionBinding assistedFactoryBinding(
|
|
TypeElement factory, Optional<TypeMirror> resolvedType) {
|
|
|
|
// If the class this is constructing has some type arguments, resolve everything.
|
|
DeclaredType factoryType = MoreTypes.asDeclared(factory.asType());
|
|
if (!factoryType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
|
|
DeclaredType resolved = MoreTypes.asDeclared(resolvedType.get());
|
|
// Validate that we're resolving from the correct type by checking that the erasure of the
|
|
// resolvedType is the same as the erasure of the factoryType.
|
|
checkState(
|
|
types.isSameType(types.erasure(resolved), types.erasure(factoryType)),
|
|
"erased expected type: %s, erased actual type: %s",
|
|
types.erasure(resolved),
|
|
types.erasure(factoryType));
|
|
factoryType = resolved;
|
|
}
|
|
|
|
ExecutableElement factoryMethod =
|
|
AssistedInjectionAnnotations.assistedFactoryMethod(factory, elements);
|
|
ExecutableType factoryMethodType =
|
|
MoreTypes.asExecutable(types.asMemberOf(factoryType, factoryMethod));
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.key(Key.builder(factoryType).build())
|
|
.bindingElement(factory)
|
|
.provisionDependencies(
|
|
ImmutableSet.of(
|
|
DependencyRequest.builder()
|
|
.key(Key.builder(factoryMethodType.getReturnType()).build())
|
|
.kind(RequestKind.PROVIDER)
|
|
.build()))
|
|
.kind(ASSISTED_FACTORY)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#PROVISION} binding for a {@code @Provides}-annotated
|
|
* method.
|
|
*
|
|
* @param contributedBy the installed module that declares or inherits the method
|
|
*/
|
|
public ProvisionBinding providesMethodBinding(
|
|
ExecutableElement providesMethod, TypeElement contributedBy) {
|
|
return setMethodBindingProperties(
|
|
ProvisionBinding.builder(),
|
|
providesMethod,
|
|
contributedBy,
|
|
keyFactory.forProvidesMethod(providesMethod, contributedBy),
|
|
this::providesMethodBinding)
|
|
.kind(PROVISION)
|
|
.scope(uniqueScopeOf(providesMethod))
|
|
.nullableType(getNullableType(providesMethod))
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#PRODUCTION} binding for a {@code @Produces}-annotated
|
|
* method.
|
|
*
|
|
* @param contributedBy the installed module that declares or inherits the method
|
|
*/
|
|
public ProductionBinding producesMethodBinding(
|
|
ExecutableElement producesMethod, TypeElement contributedBy) {
|
|
// TODO(beder): Add nullability checking with Java 8.
|
|
ProductionBinding.Builder builder =
|
|
setMethodBindingProperties(
|
|
ProductionBinding.builder(),
|
|
producesMethod,
|
|
contributedBy,
|
|
keyFactory.forProducesMethod(producesMethod, contributedBy),
|
|
this::producesMethodBinding)
|
|
.kind(PRODUCTION)
|
|
.productionKind(ProductionKind.fromProducesMethod(producesMethod))
|
|
.thrownTypes(producesMethod.getThrownTypes())
|
|
.executorRequest(dependencyRequestFactory.forProductionImplementationExecutor())
|
|
.monitorRequest(dependencyRequestFactory.forProductionComponentMonitor());
|
|
return builder.build();
|
|
}
|
|
|
|
private <C extends ContributionBinding, B extends ContributionBinding.Builder<C, B>>
|
|
B setMethodBindingProperties(
|
|
B builder,
|
|
ExecutableElement method,
|
|
TypeElement contributedBy,
|
|
Key key,
|
|
BiFunction<ExecutableElement, TypeElement, C> create) {
|
|
checkArgument(method.getKind().equals(METHOD));
|
|
ExecutableType methodType =
|
|
MoreTypes.asExecutable(
|
|
types.asMemberOf(MoreTypes.asDeclared(contributedBy.asType()), method));
|
|
if (!types.isSameType(methodType, method.asType())) {
|
|
builder.unresolved(create.apply(method, MoreElements.asType(method.getEnclosingElement())));
|
|
}
|
|
boolean isKotlinObject =
|
|
metadataUtil.isObjectClass(contributedBy)
|
|
|| metadataUtil.isCompanionObjectClass(contributedBy);
|
|
return builder
|
|
.contributionType(ContributionType.fromBindingElement(method))
|
|
.bindingElement(method)
|
|
.contributingModule(contributedBy)
|
|
.isContributingModuleKotlinObject(isKotlinObject)
|
|
.key(key)
|
|
.dependencies(
|
|
dependencyRequestFactory.forRequiredResolvedVariables(
|
|
method.getParameters(), methodType.getParameterTypes()))
|
|
.wrappedMapKeyAnnotation(wrapOptionalInEquivalence(getMapKey(method)));
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#MULTIBOUND_MAP} or {@link
|
|
* dagger.model.BindingKind#MULTIBOUND_SET} binding given a set of multibinding contribution
|
|
* bindings.
|
|
*
|
|
* @param key a key that may be satisfied by a multibinding
|
|
*/
|
|
public ContributionBinding syntheticMultibinding(
|
|
Key key, Iterable<ContributionBinding> multibindingContributions) {
|
|
ContributionBinding.Builder<?, ?> builder =
|
|
multibindingRequiresProduction(key, multibindingContributions)
|
|
? ProductionBinding.builder()
|
|
: ProvisionBinding.builder();
|
|
return builder
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.key(key)
|
|
.dependencies(
|
|
dependencyRequestFactory.forMultibindingContributions(key, multibindingContributions))
|
|
.kind(bindingKindForMultibindingKey(key))
|
|
.build();
|
|
}
|
|
|
|
private boolean multibindingRequiresProduction(
|
|
Key key, Iterable<ContributionBinding> multibindingContributions) {
|
|
if (MapType.isMap(key)) {
|
|
MapType mapType = MapType.from(key);
|
|
if (mapType.valuesAreTypeOf(Producer.class) || mapType.valuesAreTypeOf(Produced.class)) {
|
|
return true;
|
|
}
|
|
} else if (SetType.isSet(key) && SetType.from(key).elementsAreTypeOf(Produced.class)) {
|
|
return true;
|
|
}
|
|
return Iterables.any(
|
|
multibindingContributions, binding -> binding.bindingType().equals(BindingType.PRODUCTION));
|
|
}
|
|
|
|
/** Returns a {@link dagger.model.BindingKind#COMPONENT} binding for the component. */
|
|
public ProvisionBinding componentBinding(TypeElement componentDefinitionType) {
|
|
checkNotNull(componentDefinitionType);
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.bindingElement(componentDefinitionType)
|
|
.key(keyFactory.forType(componentDefinitionType.asType()))
|
|
.kind(COMPONENT)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#COMPONENT_DEPENDENCY} binding for a component's
|
|
* dependency.
|
|
*/
|
|
public ProvisionBinding componentDependencyBinding(ComponentRequirement dependency) {
|
|
checkNotNull(dependency);
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.bindingElement(dependency.typeElement())
|
|
.key(keyFactory.forType(dependency.type()))
|
|
.kind(COMPONENT_DEPENDENCY)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#COMPONENT_PROVISION} or {@link
|
|
* dagger.model.BindingKind#COMPONENT_PRODUCTION} binding for a method on a component's
|
|
* dependency.
|
|
*
|
|
* @param componentDescriptor the component with the dependency, not the dependency that has the
|
|
* method
|
|
*/
|
|
public ContributionBinding componentDependencyMethodBinding(
|
|
ComponentDescriptor componentDescriptor, ExecutableElement dependencyMethod) {
|
|
checkArgument(dependencyMethod.getKind().equals(METHOD));
|
|
checkArgument(dependencyMethod.getParameters().isEmpty());
|
|
ContributionBinding.Builder<?, ?> builder;
|
|
if (componentDescriptor.isProduction()
|
|
&& isComponentProductionMethod(elements, dependencyMethod)) {
|
|
builder =
|
|
ProductionBinding.builder()
|
|
.key(keyFactory.forProductionComponentMethod(dependencyMethod))
|
|
.kind(COMPONENT_PRODUCTION)
|
|
.thrownTypes(dependencyMethod.getThrownTypes());
|
|
} else {
|
|
builder =
|
|
ProvisionBinding.builder()
|
|
.key(keyFactory.forComponentMethod(dependencyMethod))
|
|
.nullableType(getNullableType(dependencyMethod))
|
|
.kind(COMPONENT_PROVISION)
|
|
.scope(uniqueScopeOf(dependencyMethod));
|
|
}
|
|
return builder
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.bindingElement(dependencyMethod)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#BOUND_INSTANCE} binding for a
|
|
* {@code @BindsInstance}-annotated builder setter method or factory method parameter.
|
|
*/
|
|
ProvisionBinding boundInstanceBinding(ComponentRequirement requirement, Element element) {
|
|
checkArgument(element instanceof VariableElement || element instanceof ExecutableElement);
|
|
VariableElement parameterElement =
|
|
element instanceof VariableElement
|
|
? MoreElements.asVariable(element)
|
|
: getOnlyElement(MoreElements.asExecutable(element).getParameters());
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.bindingElement(element)
|
|
.key(requirement.key().get())
|
|
.nullableType(getNullableType(parameterElement))
|
|
.kind(BOUND_INSTANCE)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#SUBCOMPONENT_CREATOR} binding declared by a component
|
|
* method that returns a subcomponent builder. Use {{@link
|
|
* #subcomponentCreatorBinding(ImmutableSet)}} for bindings declared using {@link
|
|
* Module#subcomponents()}.
|
|
*
|
|
* @param component the component that declares or inherits the method
|
|
*/
|
|
ProvisionBinding subcomponentCreatorBinding(
|
|
ExecutableElement subcomponentCreatorMethod, TypeElement component) {
|
|
checkArgument(subcomponentCreatorMethod.getKind().equals(METHOD));
|
|
checkArgument(subcomponentCreatorMethod.getParameters().isEmpty());
|
|
Key key =
|
|
keyFactory.forSubcomponentCreatorMethod(
|
|
subcomponentCreatorMethod, asDeclared(component.asType()));
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.bindingElement(subcomponentCreatorMethod)
|
|
.key(key)
|
|
.kind(SUBCOMPONENT_CREATOR)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#SUBCOMPONENT_CREATOR} binding declared using {@link
|
|
* Module#subcomponents()}.
|
|
*/
|
|
ProvisionBinding subcomponentCreatorBinding(
|
|
ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations) {
|
|
SubcomponentDeclaration subcomponentDeclaration = subcomponentDeclarations.iterator().next();
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.key(subcomponentDeclaration.key())
|
|
.kind(SUBCOMPONENT_CREATOR)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#DELEGATE} binding.
|
|
*
|
|
* @param delegateDeclaration the {@code @Binds}-annotated declaration
|
|
* @param actualBinding the binding that satisfies the {@code @Binds} declaration
|
|
*/
|
|
ContributionBinding delegateBinding(
|
|
DelegateDeclaration delegateDeclaration, ContributionBinding actualBinding) {
|
|
switch (actualBinding.bindingType()) {
|
|
case PRODUCTION:
|
|
return buildDelegateBinding(
|
|
ProductionBinding.builder().nullableType(actualBinding.nullableType()),
|
|
delegateDeclaration,
|
|
Producer.class);
|
|
|
|
case PROVISION:
|
|
return buildDelegateBinding(
|
|
ProvisionBinding.builder()
|
|
.scope(uniqueScopeOf(delegateDeclaration.bindingElement().get()))
|
|
.nullableType(actualBinding.nullableType()),
|
|
delegateDeclaration,
|
|
Provider.class);
|
|
|
|
case MEMBERS_INJECTION: // fall-through to throw
|
|
}
|
|
throw new AssertionError("bindingType: " + actualBinding);
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#DELEGATE} binding used when there is no binding that
|
|
* satisfies the {@code @Binds} declaration.
|
|
*/
|
|
public ContributionBinding unresolvedDelegateBinding(DelegateDeclaration delegateDeclaration) {
|
|
return buildDelegateBinding(
|
|
ProvisionBinding.builder().scope(uniqueScopeOf(delegateDeclaration.bindingElement().get())),
|
|
delegateDeclaration,
|
|
Provider.class);
|
|
}
|
|
|
|
private ContributionBinding buildDelegateBinding(
|
|
ContributionBinding.Builder<?, ?> builder,
|
|
DelegateDeclaration delegateDeclaration,
|
|
Class<?> frameworkType) {
|
|
boolean isKotlinObject =
|
|
metadataUtil.isObjectClass(delegateDeclaration.contributingModule().get())
|
|
|| metadataUtil.isCompanionObjectClass(delegateDeclaration.contributingModule().get());
|
|
return builder
|
|
.contributionType(delegateDeclaration.contributionType())
|
|
.bindingElement(delegateDeclaration.bindingElement().get())
|
|
.contributingModule(delegateDeclaration.contributingModule().get())
|
|
.isContributingModuleKotlinObject(isKotlinObject)
|
|
.key(keyFactory.forDelegateBinding(delegateDeclaration, frameworkType))
|
|
.dependencies(delegateDeclaration.delegateRequest())
|
|
.wrappedMapKeyAnnotation(delegateDeclaration.wrappedMapKey())
|
|
.kind(DELEGATE)
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns an {@link dagger.model.BindingKind#OPTIONAL} binding for {@code key}.
|
|
*
|
|
* @param requestKind the kind of request for the optional binding
|
|
* @param underlyingKeyBindings the possibly empty set of bindings that exist in the component for
|
|
* the underlying (non-optional) key
|
|
*/
|
|
ContributionBinding syntheticOptionalBinding(
|
|
Key key,
|
|
RequestKind requestKind,
|
|
ImmutableCollection<? extends Binding> underlyingKeyBindings) {
|
|
if (underlyingKeyBindings.isEmpty()) {
|
|
return ProvisionBinding.builder()
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.key(key)
|
|
.kind(OPTIONAL)
|
|
.build();
|
|
}
|
|
|
|
boolean requiresProduction =
|
|
underlyingKeyBindings.stream()
|
|
.anyMatch(binding -> binding.bindingType() == BindingType.PRODUCTION)
|
|
|| requestKind.equals(RequestKind.PRODUCER) // handles producerFromProvider cases
|
|
|| requestKind.equals(RequestKind.PRODUCED); // handles producerFromProvider cases
|
|
|
|
return (requiresProduction ? ProductionBinding.builder() : ProvisionBinding.builder())
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.key(key)
|
|
.kind(OPTIONAL)
|
|
.dependencies(dependencyRequestFactory.forSyntheticPresentOptionalBinding(key, requestKind))
|
|
.build();
|
|
}
|
|
|
|
/** Returns a {@link dagger.model.BindingKind#MEMBERS_INJECTOR} binding. */
|
|
public ProvisionBinding membersInjectorBinding(
|
|
Key key, MembersInjectionBinding membersInjectionBinding) {
|
|
return ProvisionBinding.builder()
|
|
.key(key)
|
|
.contributionType(ContributionType.UNIQUE)
|
|
.kind(MEMBERS_INJECTOR)
|
|
.bindingElement(MoreTypes.asTypeElement(membersInjectionBinding.key().type()))
|
|
.provisionDependencies(membersInjectionBinding.dependencies())
|
|
.injectionSites(membersInjectionBinding.injectionSites())
|
|
.build();
|
|
}
|
|
|
|
/**
|
|
* Returns a {@link dagger.model.BindingKind#MEMBERS_INJECTION} binding.
|
|
*
|
|
* @param resolvedType if {@code declaredType} is a generic class and {@code resolvedType} is a
|
|
* parameterization of that type, the returned binding will be for the resolved type
|
|
*/
|
|
// TODO(dpb): See if we can just pass one nongeneric/parameterized type.
|
|
public MembersInjectionBinding membersInjectionBinding(
|
|
DeclaredType declaredType, Optional<TypeMirror> resolvedType) {
|
|
// If the class this is injecting has some type arguments, resolve everything.
|
|
if (!declaredType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
|
|
DeclaredType resolved = asDeclared(resolvedType.get());
|
|
// Validate that we're resolving from the correct type.
|
|
checkState(
|
|
types.isSameType(types.erasure(resolved), types.erasure(declaredType)),
|
|
"erased expected type: %s, erased actual type: %s",
|
|
types.erasure(resolved),
|
|
types.erasure(declaredType));
|
|
declaredType = resolved;
|
|
}
|
|
ImmutableSortedSet<InjectionSite> injectionSites =
|
|
injectionSiteFactory.getInjectionSites(declaredType);
|
|
ImmutableSet<DependencyRequest> dependencies =
|
|
injectionSites.stream()
|
|
.flatMap(injectionSite -> injectionSite.dependencies().stream())
|
|
.collect(toImmutableSet());
|
|
|
|
Key key = keyFactory.forMembersInjectedType(declaredType);
|
|
TypeElement typeElement = MoreElements.asType(declaredType.asElement());
|
|
return new AutoValue_MembersInjectionBinding(
|
|
key,
|
|
dependencies,
|
|
typeElement,
|
|
hasNonDefaultTypeParameters(typeElement, key.type(), types)
|
|
? Optional.of(
|
|
membersInjectionBinding(asDeclared(typeElement.asType()), Optional.empty()))
|
|
: Optional.empty(),
|
|
injectionSites);
|
|
}
|
|
}
|