declaredRequirementsByType =
Multimaps.filterKeys(
creator.unvalidatedRequirementElements(),
creatorModuleAndDependencyRequirements::contains)
.entries()
.stream()
.collect(
toImmutableSetMultimap(
entry -> entry.getKey().type().getTypeName(), Entry::getValue));
declaredRequirementsByType
.asMap()
.forEach(
(type, elementsForType) -> {
if (elementsForType.size() > 1) {
// TODO(cgdecker): Attach this error message to the factory method rather than
// the component type if the elements are factory method parameters AND the
// factory method is defined by the factory type itself and not by a supertype.
report(component)
.addError(
String.format(
messages.multipleSettersForModuleOrDependencyType(),
type,
transform(
elementsForType, element -> formatElement(element, container))),
creator.typeElement());
}
});
// TODO(cgdecker): Duplicate binding validation should handle the case of multiple elements
// that set the same bound-instance Key, but validating that here would make it fail faster
// for subcomponents.
}
private String formatElement(XElement element, XType container) {
// TODO(cgdecker): Extract some or all of this to another class?
// But note that it does different formatting for parameters than
// DaggerElements.elementToString(Element).
if (isMethod(element)) {
return methodSignatureFormatter.format(asMethod(element), Optional.of(container));
} else if (isMethodParameter(element)) {
return formatParameter(asMethodParameter(element), container);
}
// This method shouldn't be called with any other type of element.
throw new AssertionError();
}
private String formatParameter(XExecutableParameterElement parameter, XType container) {
// TODO(cgdecker): Possibly leave the type (and annotations?) off of the parameters here and
// just use their names, since the type will be redundant in the context of the error message.
StringJoiner joiner = new StringJoiner(" ");
parameter.getAllAnnotations().stream()
.map(XAnnotation::getQualifiedName)
.forEach(joiner::add);
XType parameterType = resolveParameterType(parameter, container);
return joiner
.add(stripCommonTypePrefixes(parameterType.getTypeName().toString()))
.add(getSimpleName(parameter))
.toString();
}
private XType resolveParameterType(XExecutableParameterElement parameter, XType container) {
checkArgument(isMethod(parameter.getEnclosingElement()));
XMethodElement method = asMethod(parameter.getEnclosingElement());
int parameterIndex = method.getParameters().indexOf(parameter);
XMethodType methodType = method.asMemberOf(container);
return methodType.getParameterTypes().get(parameterIndex);
}
/**
* Validates that scopes do not participate in a scoping cycle - that is to say, scoped
* components are in a hierarchical relationship terminating with Singleton.
*
* As a side-effect, this means scoped components cannot have a dependency cycle between
* themselves, since a component's presence within its own dependency path implies a cyclical
* relationship between scopes. However, cycles in component dependencies are explicitly checked
* in {@link #validateComponentDependencyHierarchy(ComponentDescriptor)}.
*/
private void validateDependencyScopeHierarchy(
ComponentDescriptor component,
XTypeElement dependency,
Deque> scopeStack,
Deque scopedDependencyStack) {
ImmutableSet scopes = injectionAnnotations.getScopes(dependency);
if (stackOverlaps(scopeStack, scopes)) {
scopedDependencyStack.push(dependency);
// Current scope has already appeared in the component chain.
StringBuilder message = new StringBuilder();
message.append(component.typeElement().getQualifiedName());
message.append(" depends on scoped components in a non-hierarchical scope ordering:\n");
appendIndentedComponentsList(message, scopedDependencyStack);
if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()) {
reportComponentItem(
compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
component,
message.toString());
}
scopedDependencyStack.pop();
} else if (compilerOptions.validateTransitiveComponentDependencies()
// Always validate direct component dependencies referenced by this component regardless
// of the flag value
|| scopedDependencyStack.isEmpty()) {
// TODO(beder): transitively check scopes of production components too.
rootComponentAnnotation(dependency, superficialValidation)
.filter(componentAnnotation -> !componentAnnotation.isProduction())
.ifPresent(
componentAnnotation -> {
ImmutableSet scopedDependencies =
scopedTypesIn(componentAnnotation.dependencies());
if (!scopedDependencies.isEmpty()) {
// empty can be ignored (base-case)
scopeStack.push(scopes);
scopedDependencyStack.push(dependency);
for (XTypeElement scopedDependency : scopedDependencies) {
validateDependencyScopeHierarchy(
component, scopedDependency, scopeStack, scopedDependencyStack);
}
scopedDependencyStack.pop();
scopeStack.pop();
}
}); // else: we skip component dependencies which are not components
}
}
private boolean stackOverlaps(Deque> stack, ImmutableSet set) {
for (ImmutableSet entry : stack) {
if (!Sets.intersection(entry, set).isEmpty()) {
return true;
}
}
return false;
}
/** Appends and formats a list of indented component types (with their scope annotations). */
private void appendIndentedComponentsList(StringBuilder message, Iterable types) {
for (XTypeElement scopedComponent : types) {
message.append(INDENT);
for (Scope scope : injectionAnnotations.getScopes(scopedComponent)) {
message.append(getReadableSource(scope)).append(' ');
}
message
.append(stripCommonTypePrefixes(scopedComponent.getQualifiedName().toString()))
.append('\n');
}
}
/**
* Returns a set of type elements containing only those found in the input set that have a
* scoping annotation.
*/
private ImmutableSet scopedTypesIn(Collection types) {
return types.stream()
.filter(type -> !injectionAnnotations.getScopes(type).isEmpty())
.collect(toImmutableSet());
}
}
}