/** * Returns {@code true} if {@code type} is a parameterized type of {@code kind}'s {@link * #frameworkClass(RequestKind) framework class}. */ private static boolean matchesKind(RequestKind kind, TypeMirror type) { return isType(type) && isTypeOf(frameworkClass(kind), type) && !asDeclared(type).getTypeArguments().isEmpty(); }
@Override public Void visitDeclared(DeclaredType t, Set<TypeElement> p) { TypeElement typeElement = MoreTypes.asTypeElement(t); if (typeElement.getKind() == ElementKind.ANNOTATION_TYPE) { nestedAnnotationElements(typeElement, p); } return null; } };
/** A multibinding declaration for a {@link Multibinds @Multibinds} method. */ MultibindingDeclaration forMultibindsMethod( ExecutableElement moduleMethod, TypeElement moduleElement) { checkArgument(isAnnotationPresent(moduleMethod, Multibinds.class)); return forDeclaredMethod( moduleMethod, MoreTypes.asExecutable( types.asMemberOf(MoreTypes.asDeclared(moduleElement.asType()), moduleMethod)), moduleElement); }
static ComponentRequirement forDependency(TypeMirror type) { return new AutoValue_ComponentRequirement( Kind.DEPENDENCY, MoreTypes.equivalence().wrap(checkNotNull(type)), Optional.empty(), Optional.empty(), simpleVariableName(MoreTypes.asTypeElement(type))); }
ExecutableElement componentMethod) { ExecutableType resolvedComponentMethod = MoreTypes.asExecutable( types.asMemberOf(MoreTypes.asDeclared(componentElement.asType()), componentMethod)); TypeMirror returnType = resolvedComponentMethod.getReturnType(); if (returnType.getKind().equals(DECLARED)) { if (MoreTypes.isTypeOf(Provider.class, returnType) || MoreTypes.isTypeOf(Lazy.class, returnType)) { return ComponentMethodDescriptor.forProvision( componentMethod, componentMethod, resolvedComponentMethod)); } else if (!getQualifier(componentMethod).isPresent()) { Element returnTypeElement = MoreTypes.asElement(returnType); if (isSubcomponent(returnTypeElement)) { return ComponentMethodDescriptor.forSubcomponent( if (parameterTypes.size() == 1 && (returnType.getKind().equals(VOID) || MoreTypes.equivalence().equivalent(returnType, parameterTypes.get(0)))) { return ComponentMethodDescriptor.forMembersInjection( componentMethod,
@Override public DeclaredType getAnnotationType() { return MoreTypes.asDeclared(annotationType.asType()); }
DeclaredType subjectType = MoreTypes.asDeclared(subject.asType()); .forEachOrdered( method -> { ExecutableType resolvedMethod = asExecutable(types.asMemberOf(subjectType, method)); List<? extends TypeMirror> parameterTypes = resolvedMethod.getParameterTypes(); List<? extends VariableElement> parameters = method.getParameters(); .collect(toImmutableSet())); if (subcomponentAnnotation.isPresent()) { referencedSubcomponents.put(MoreTypes.asElement(returnType), method); validateSubcomponentMethod( report, ComponentKind.forAnnotatedElement(MoreTypes.asTypeElement(returnType)).get(), method, parameters, } else if (subcomponentBuilderAnnotation.isPresent()) { referencedSubcomponents.put( MoreTypes.asElement(returnType).getEnclosingElement(), method); validateSubcomponentCreatorMethod( report, method, parameters, returnType, validatedSubcomponentCreators);
if (MoreTypes.asDeclared(injectedType).getTypeArguments().isEmpty()) { builder.injectedType(ClassName.get(MoreTypes.asTypeElement(injectedType))); } else { reporter.reportError( for (TypeMirror module : getAnnotationValue(annotation, "modules").accept(new AllTypesVisitor(), null)) { if (isAnnotationPresent(MoreTypes.asElement(module), Module.class)) { builder.modulesBuilder().add((ClassName) TypeName.get(module)); } else {
private ComponentDescriptor create(TypeElement typeElement, ComponentKind kind) { AnnotationMirror componentAnnotation = getAnnotationMirror(typeElement, kind.annotation()).get(); DeclaredType declaredComponentType = MoreTypes.asDeclared(typeElement.asType()); ImmutableSet<ComponentRequirement> componentDependencies = kind.isRoot() && !kind.isForModuleValidation() for (ExecutableElement componentMethod : unimplementedMethods) { ExecutableType resolvedMethod = MoreTypes.asExecutable(types.asMemberOf(declaredComponentType, componentMethod)); ComponentMethodDescriptor componentMethodDescriptor = getDescriptorForComponentMethod(typeElement, kind, componentMethod); componentMethodDescriptor, create( MoreElements.asType(MoreTypes.asElement(resolvedMethod.getReturnType())), componentMethodDescriptor.kind().componentKind())); break; create( MoreElements.asType( MoreTypes.asElement(resolvedMethod.getReturnType()) .getEnclosingElement()), componentMethodDescriptor.kind().componentKind()));
/** * Returns a {@link SetType} for {@code type}. * * @throws IllegalArgumentException if {@code type} is not a {@link Set} type */ static SetType from(TypeMirror type) { checkArgument(isSet(type), "%s must be a Set", type); return new AutoValue_SetType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type))); }
/** * Returns a stream of the dependencies of {@code binding} that have a key type of {@code Map<K, * Provider<AndroidInjector.Factory<?>>}. */ private Stream<Binding> injectorMapDependencies(Binding binding, BindingGraph graph) { return graph.requestedBindings(binding).stream() .filter(requestedBinding -> requestedBinding.kind().equals(BindingKind.MULTIBOUND_MAP)) .filter( requestedBinding -> { TypeMirror valueType = MoreTypes.asDeclared(requestedBinding.key().type()).getTypeArguments().get(1); if (!MoreTypes.isTypeOf(Provider.class, valueType) || !valueType.getKind().equals(TypeKind.DECLARED)) { return false; } TypeMirror providedType = MoreTypes.asDeclared(valueType).getTypeArguments().get(0); return MoreTypes.isTypeOf(AndroidInjector.Factory.class, providedType); }); }
private ImmutableSet<TypeElement> subgraphFactoryMethodParameters( ChildFactoryMethodEdge edge, BindingGraph bindingGraph) { ComponentNode parent = (ComponentNode) bindingGraph.network().incidentNodes(edge).source(); DeclaredType parentType = asDeclared(parent.componentPath().currentComponent().asType()); ExecutableType factoryMethodType = asExecutable(types.asMemberOf(parentType, edge.factoryMethod())); return asTypeElements(factoryMethodType.getParameterTypes()); }
@Override public CodeBlock creationExpression() { TypeMirror membersInjectedType = getOnlyElement(MoreTypes.asDeclared(binding.key().type()).getTypeArguments()); CodeBlock membersInjector = binding.injectionSites().isEmpty() ? CodeBlock.of("$T.<$T>noOp()", MEMBERS_INJECTORS, membersInjectedType) : CodeBlock.of( "$T.create($L)", membersInjectorNameForType(MoreTypes.asTypeElement(membersInjectedType)), componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding)); // TODO(ronshapiro): consider adding a MembersInjectorBindingExpression to return this directly // (as it's rarely requested as a Provider). return CodeBlock.of("$T.create($L)", INSTANCE_FACTORY, membersInjector); }
checkArgument(method.getKind().equals(METHOD)); ExecutableType methodType = MoreTypes.asExecutable( types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), method)); ContributionType contributionType = ContributionType.fromBindingMethod(method); TypeMirror returnType = methodType.getReturnType(); if (frameworkType.isPresent() && frameworkType.get().equals(elements.getTypeElement(Producer.class)) && isType(returnType)) { if (isFutureType(methodType.getReturnType())) { returnType = getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments()); } else if (contributionType.equals(ContributionType.SET_VALUES) && SetType.isSet(returnType)) {
@CanIgnoreReturnValue private Set<TypeElement> collectIncludedModules( Set<TypeElement> includedModules, TypeElement moduleElement) { TypeMirror superclass = moduleElement.getSuperclass(); if (!superclass.getKind().equals(NONE)) { verify(superclass.getKind().equals(DECLARED)); TypeElement superclassElement = MoreTypes.asTypeElement(superclass); if (!superclassElement.getQualifiedName().contentEquals(Object.class.getCanonicalName())) { collectIncludedModules(includedModules, superclassElement); } } Optional<AnnotationMirror> moduleAnnotation = getModuleAnnotation(moduleElement); if (moduleAnnotation.isPresent()) { includedModules.addAll(MoreTypes.asTypeElements(getModuleIncludes(moduleAnnotation.get()))); includedModules.addAll(implicitlyIncludedModules(moduleElement)); } return includedModules; }
private static boolean typeIsOneOf(Set<Class<?>> classes, TypeMirror type) { for (Class<?> clazz : classes) { if (MoreTypes.isTypeOf(clazz, type)) { return true; } } return false; }
/** Creates a new {@link ComponentCreatorDescriptor} for the given creator {@code type}. */ static ComponentCreatorDescriptor create( DeclaredType type, DaggerElements elements, DaggerTypes types, DependencyRequestFactory dependencyRequestFactory) { TypeElement typeElement = asTypeElement(type); TypeMirror componentType = typeElement.getEnclosingElement().asType(); ImmutableSetMultimap.Builder<ComponentRequirement, ExecutableElement> requirementElements = ImmutableSetMultimap.builder(); ExecutableElement factoryMethod = null; for (ExecutableElement method : elements.getUnimplementedMethods(typeElement)) { ExecutableType resolvedMethodType = MoreTypes.asExecutable(types.asMemberOf(type, method)); if (types.isSubtype(componentType, resolvedMethodType.getReturnType())) { factoryMethod = method; } else { VariableElement parameter = getOnlyElement(method.getParameters()); TypeMirror parameterType = getOnlyElement(resolvedMethodType.getParameterTypes()); requirementElements.put( requirement(method, parameter, parameterType, dependencyRequestFactory), method); } } verify(factoryMethod != null); // validation should have ensured this. return new AutoValue_ComponentCreatorDescriptor( typeElement, factoryMethod, requirementElements.build()); }
/** * Returns {@code true} iff the given element has an {@link AnnotationMirror} whose {@linkplain * AnnotationMirror#getAnnotationType() annotation type} is equivalent to {@code annotationType}. */ static boolean isAnnotationPresent(Element element, TypeMirror annotationType) { return element .getAnnotationMirrors() .stream() .map(AnnotationMirror::getAnnotationType) .anyMatch(candidate -> MoreTypes.equivalence().equivalent(candidate, annotationType)); }
private ImmutableList<TypeMirror> methodParameterTypes(DeclaredType type, String methodName) { ImmutableList.Builder<ExecutableElement> methodsForName = ImmutableList.builder(); for (ExecutableElement method : methodsIn(MoreElements.asType(type.asElement()).getEnclosedElements())) { if (method.getSimpleName().contentEquals(methodName)) { methodsForName.add(method); } } ExecutableElement method = getOnlyElement(methodsForName.build()); return ImmutableList.copyOf( MoreTypes.asExecutable(types.asMemberOf(type, method)).getParameterTypes()); }