private ImmutableSet<DependencyEdge> nonNullableDependencies( BindingGraph bindingGraph, dagger.model.Binding binding) { return bindingGraph.network().inEdges(binding).stream() .flatMap(instancesOf(DependencyEdge.class)) .filter(edge -> !edge.dependencyRequest().isNullable()) .collect(toImmutableSet()); }
@Override public String toString() { String string = dependencyRequest .requestElement() .map(DaggerElements::elementToString) .orElseGet( () -> "synthetic request for " + dependencyRequest.kind().format(dependencyRequest.key())); return entryPoint ? string + " (entry point)" : string; } }
private String entryPointErrorMessage(DependencyEdge entryPoint) { return String.format( "%s is a provision entry-point, which cannot depend on a production.", entryPoint.dependencyRequest().key()); }
/** Returns a name of the variable representing this dependency's future. */ private static String dependencyFutureName(DependencyRequest dependency) { return dependency.requestElement().get().getSimpleName() + "Future"; }
private static ComponentRequirement requirement( ExecutableElement method, VariableElement parameter, TypeMirror type, DependencyRequestFactory dependencyRequestFactory) { if (isAnnotationPresent(method, BindsInstance.class)) { DependencyRequest request = dependencyRequestFactory.forRequiredResolvedVariable(parameter, type); return ComponentRequirement.forBoundInstance( request.key(), request.isNullable(), method.getSimpleName().toString()); } return ConfigurationAnnotations.getModuleAnnotation(asTypeElement(type)).isPresent() ? ComponentRequirement.forModule(type) : ComponentRequirement.forDependency(type); } }
DependencyRequest forComponentMembersInjectionMethod( ExecutableElement membersInjectionMethod, ExecutableType membersInjectionMethodType) { checkNotNull(membersInjectionMethod); checkNotNull(membersInjectionMethodType); Optional<AnnotationMirror> qualifier = InjectionAnnotations.getQualifier(membersInjectionMethod); checkArgument(!qualifier.isPresent()); TypeMirror membersInjectedType = getOnlyElement(membersInjectionMethodType.getParameterTypes()); return DependencyRequest.builder() .kind(MEMBERS_INJECTION) .key(keyFactory.forMembersInjectedType(membersInjectedType)) .requestElement(membersInjectionMethod) .build(); }
private static boolean isAsyncDependency(DependencyRequest dependency) { switch (dependency.kind()) { case INSTANCE: case PRODUCED: return true; default: return false; } }
@Override public String visitExecutableAsMethod(ExecutableElement method, DependencyRequest request) { return INDENT + request.key() + " is " + componentMethodRequestVerb(request) + " at\n" + DOUBLE_INDENT + elementToString(method); }
@Override String applyArgName() { String argName = asyncDependency.requestElement().get().getSimpleName().toString(); if (argName.equals("module")) { return "moduleArg"; } return argName; }
DependencyRequest forProductionImplementationExecutor() { return DependencyRequest.builder() .kind(PROVIDER) .key(keyFactory.forProductionImplementationExecutor()) .build(); }
/** * Returns the verb for a component method dependency request. Returns "produced", "provided", or * "injected", depending on the kind of request. */ private String componentMethodRequestVerb(DependencyRequest request) { switch (request.kind()) { case FUTURE: case PRODUCER: return "produced"; case INSTANCE: case LAZY: case PROVIDER: case PROVIDER_OF_LAZY: return "provided"; case MEMBERS_INJECTION: return "injected"; case PRODUCED: default: throw new AssertionError("illegal request kind for method: " + request); } } }
@Override ImmutableList<CodeBlock> parameterCodeBlocks() { ImmutableList.Builder<CodeBlock> parameterCodeBlocks = ImmutableList.builder(); for (DependencyRequest dependency : binding.explicitDependencies()) { parameterCodeBlocks.add( frameworkTypeUsageStatement( CodeBlock.of("$N", fields.get(dependency.key())), dependency.kind())); } return parameterCodeBlocks.build(); } }
/** * Returns the parameter type for {@code dependency}. If the raw type is not accessible, returns * {@link Object}. */ private static TypeName accessibleType(DependencyRequest dependency) { TypeName typeName = requestTypeName(dependency.kind(), accessibleType(dependency.key().type())); return dependency .requestElement() .map(element -> element.asType().getKind().isPrimitive()) .orElse(false) ? typeName.unbox() : typeName; }
protected final ImmutableSet<FrameworkDependency> frameworkDependenciesToImplement() { ImmutableSet<Key> alreadyImplementedKeys = componentImplementation.superclassContributionsMade(bindingRequest()).stream() .map(dependency -> dependency.key()) .collect(toImmutableSet()); return binding.frameworkDependencies().stream() .filter(frameworkDependency -> !alreadyImplementedKeys.contains(frameworkDependency.key())) .collect(toImmutableSet()); }
@Override public String format(DependencyRequest request) { return request .requestElement() .map(element -> element.accept(formatVisitor, request)) .orElse(""); }
DependencyRequest forProductionComponentMonitor() { return DependencyRequest.builder() .kind(PROVIDER) .key(keyFactory.forProductionComponentMonitor()) .build(); }
/** * Returns the {@link FrameworkType} to use for a collection of requests of the same {@link Key}. * This allows factories to only take a single argument for multiple requests of the same key. */ FrameworkType getFrameworkType(Set<DependencyRequest> requests) { Set<FrameworkType> frameworkTypes = requests.stream().map(request -> getFrameworkType(request.kind())).collect(toSet()); return frameworkTypes.size() == 1 ? getOnlyElement(frameworkTypes) : FrameworkType.PROVIDER; } }
@Override public String visitVariable(VariableElement variable, DependencyRequest request) { TypeMirror requestedType = requestType(request.kind(), request.key().type(), types); return INDENT + formatQualifier(request.key().qualifier()) + requestedType + " is injected at\n" + DOUBLE_INDENT + elementToString(variable); }
static String name(DependencyRequest dependency) { if (!dependency.requestElement().isPresent()) { return simpleVariableName(MoreTypes.asTypeElement(dependency.key().type())); String variableName = dependency.requestElement().get().getSimpleName().toString(); if (Ascii.isUpperCase(variableName.charAt(0))) { variableName = toLowerCamel(variableName); switch (dependency.kind()) { case INSTANCE: return variableName;