> frameworkDependencies =
memoize(
() ->
dependencyAssociations()
.stream()
.map(DependencyAssociation::frameworkDependency)
.collect(toImmutableList()));
/**
* The framework dependencies of {@code binding}. There will be one element for each different
* binding key in the {@linkplain Binding#unresolved() unresolved} version of {@code
* binding}.
*
* For example, given the following modules:
*
*
* {@literal @Module} abstract class {@literal BaseModule} {
* {@literal @Provides} Foo provideFoo(T t, String string) {
* return …;
* }
* }
*
* {@literal @Module} class StringModule extends {@literal BaseModule} {}
*
*
* Both dependencies of {@code StringModule.provideFoo} have the same binding key: {@code String}.
* But there are still two dependencies, because in the unresolved binding they have different
* binding keys:
*
*
* - {@code T}
*
- {@code String t}
*
- {@code String}
*
- {@code String string}
*
*
* Note that the sets returned by this method when called on the same binding will be equal,
* and their elements will be in the same order.
*/
/* TODO(dpb): The stable-order postcondition is actually hard to verify in code for two equal
* instances of Binding, because it really depends on the order of the binding's dependencies,
* and two equal instances of Binding may have the same dependencies in a different order. */
final ImmutableList frameworkDependencies() {
return frameworkDependencies.get();
}
/**
* Associates a {@link FrameworkDependency} with the set of {@link DependencyRequest} instances
* that correlate for a binding.
*/
@AutoValue
abstract static class DependencyAssociation {
abstract FrameworkDependency frameworkDependency();
abstract ImmutableSet dependencyRequests();
static DependencyAssociation create(
FrameworkDependency frameworkDependency, Iterable dependencyRequests) {
return new AutoValue_Binding_DependencyAssociation(
frameworkDependency, ImmutableSet.copyOf(dependencyRequests));
}
}
private final Supplier> dependencyAssociations =
memoize(
() -> {
FrameworkTypeMapper frameworkTypeMapper =
FrameworkTypeMapper.forBindingType(bindingType());
ImmutableList.Builder list = ImmutableList.builder();
for (Set requests : groupByUnresolvedKey()) {
list.add(
DependencyAssociation.create(
FrameworkDependency.create(
getOnlyElement(
requests.stream().map(DependencyRequest::key).collect(toSet())),
frameworkTypeMapper.getFrameworkType(requests)),
requests));
}
return list.build();
});
/**
* Returns the same {@link FrameworkDependency} instances from {@link #frameworkDependencies}, but
* with the set of {@link DependencyRequest} instances with which each is associated.
*
* Ths method returns a list of {@link Map.Entry entries} rather than a {@link Map} or {@link
* com.google.common.collect.Multimap} because any given {@link FrameworkDependency} may appear
* multiple times if the {@linkplain Binding#unresolved() unresolved} binding requires it. If that
* distinction is not important, the entries can be merged into a single mapping.
*/
final ImmutableList dependencyAssociations() {
return dependencyAssociations.get();
}
private final Supplier>
frameworkDependenciesMap =
memoize(
() -> {
ImmutableMap.Builder frameworkDependencies =
ImmutableMap.builder();
for (DependencyAssociation dependencyAssociation : dependencyAssociations()) {
for (DependencyRequest dependencyRequest :
dependencyAssociation.dependencyRequests()) {
frameworkDependencies.put(
dependencyRequest, dependencyAssociation.frameworkDependency());
}
}
return frameworkDependencies.build();
});
/**
* Returns the mapping from each {@linkplain #dependencies dependency} to its associated {@link
* FrameworkDependency}.
*/
final ImmutableMap
dependenciesToFrameworkDependenciesMap() {
return frameworkDependenciesMap.get();
}
/**
* Groups {@code binding}'s implicit dependencies by their binding key, using the dependency keys
* from the {@link Binding#unresolved()} binding if it exists.
*/
private ImmutableList> groupByUnresolvedKey() {
ImmutableSetMultimap.Builder dependenciesByKeyBuilder =
ImmutableSetMultimap.builder();
Iterator dependencies = dependencies().iterator();
Binding unresolved = unresolved().isPresent() ? unresolved().get() : this;
Iterator unresolvedDependencies = unresolved.dependencies().iterator();
while (dependencies.hasNext()) {
dependenciesByKeyBuilder.put(unresolvedDependencies.next().key(), dependencies.next());
}
return ImmutableList.copyOf(
Multimaps.asMap(
dependenciesByKeyBuilder.orderValuesBy(SourceFiles.DEPENDENCY_ORDERING).build())
.values());
}
/**
* If this binding's key's type parameters are different from those of the
* {@link #bindingTypeElement()}, this is the binding for the {@link #bindingTypeElement()}'s
* unresolved type.
*/
abstract Optional unresolved();
Optional scope() {
return Optional.empty();
}
// TODO(sameb): Remove the TypeElement parameter and pull it from the TypeMirror.
static boolean hasNonDefaultTypeParameters(
TypeElement element, TypeMirror type, DaggerTypes types) {
// If the element has no type parameters, nothing can be wrong.
if (element.getTypeParameters().isEmpty()) {
return false;
}
List defaultTypes = Lists.newArrayList();
for (TypeParameterElement parameter : element.getTypeParameters()) {
defaultTypes.add(parameter.asType());
}
List actualTypes =
type.accept(
new SimpleTypeVisitor6, Void>() {
@Override
protected List defaultAction(TypeMirror e, Void p) {
return ImmutableList.of();
}
@Override
public List visitDeclared(DeclaredType t, Void p) {
return ImmutableList.copyOf(t.getTypeArguments());
}
},
null);
// The actual type parameter size can be different if the user is using a raw type.
if (defaultTypes.size() != actualTypes.size()) {
return true;
}
for (int i = 0; i < defaultTypes.size(); i++) {
if (!types.isSameType(defaultTypes.get(i), actualTypes.get(i))) {
return true;
}
}
return false;
}
}