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()); }
/** * Formats an ExecutableElement as if it were contained within the container, if the container is * present. */ public String format(ExecutableElement method, Optional<DeclaredType> container) { TypeElement type = MoreElements.asType(method.getEnclosingElement()); ExecutableType executableType = MoreTypes.asExecutable(method.asType()); if (container.isPresent()) { executableType = MoreTypes.asExecutable(types.asMemberOf(container.get(), method)); type = MoreElements.asType(container.get().asElement()); } return format(method, executableType, type); }
@Override public String format(ExecutableElement method) { return MethodSignatureFormatter.this.format( method, MoreTypes.asExecutable(types.asMemberOf(declaredType, method)), MoreElements.asType(method.getEnclosingElement())); } };
/** 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); }
private InjectionSite injectionSiteForInjectMethod( ExecutableElement methodElement, DeclaredType containingType) { checkNotNull(methodElement); checkArgument(methodElement.getKind().equals(ElementKind.METHOD)); ExecutableType resolved = MoreTypes.asExecutable(types.asMemberOf(containingType, methodElement)); return new AutoValue_MembersInjectionBinding_InjectionSite( InjectionSite.Kind.METHOD, methodElement, dependencyRequestFactory.forRequiredResolvedVariables( methodElement.getParameters(), resolved.getParameterTypes())); }
private void checkConflictingEntryPoints(ValidationReport.Builder<TypeElement> report) { DeclaredType componentType = asDeclared(report.getSubject().asType()); // Collect entry point methods that are not overridden by others. If the "same" method is // inherited from more than one supertype, each will be in the multimap. SetMultimap<String, ExecutableElement> entryPointMethods = HashMultimap.create(); methodsIn(elements.getAllMembers(report.getSubject())) .stream() .filter( method -> isEntryPoint(method, asExecutable(types.asMemberOf(componentType, method)))) .forEach( method -> addMethodUnlessOverridden( method, entryPointMethods.get(method.getSimpleName().toString()))); for (Set<ExecutableElement> methods : asMap(entryPointMethods).values()) { if (distinctKeys(methods, report.getSubject()).size() > 1) { reportConflictingEntryPoints(methods, report); } } }
private DependencyRequest dependencyRequest(ExecutableElement method, TypeElement component) { ExecutableType methodType = asExecutable(types.asMemberOf(asDeclared(component.asType()), method)); return ComponentKind.forAnnotatedElement(component).get().isProducer() ? dependencyRequestFactory.forComponentProductionMethod(method, methodType) : dependencyRequestFactory.forComponentProvisionMethod(method, methodType); }
DelegateDeclaration create( ExecutableElement bindsMethod, TypeElement contributingModule) { checkArgument(MoreElements.isAnnotationPresent(bindsMethod, Binds.class)); ExecutableType resolvedMethod = MoreTypes.asExecutable( types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), bindsMethod)); DependencyRequest delegateRequest = dependencyRequestFactory.forRequiredResolvedVariable( Iterables.getOnlyElement(bindsMethod.getParameters()), Iterables.getOnlyElement(resolvedMethod.getParameterTypes())); return new AutoValue_DelegateDeclaration( ContributionType.fromBindingMethod(bindsMethod), keyFactory.forBindsMethod(bindsMethod, contributingModule), Optional.<Element>of(bindsMethod), Optional.of(contributingModule), delegateRequest, wrapOptionalInEquivalence(getMapKey(bindsMethod))); } }
Key forSubcomponentCreatorMethod( ExecutableElement subcomponentCreatorMethod, DeclaredType declaredContainer) { checkArgument(subcomponentCreatorMethod.getKind().equals(METHOD)); ExecutableType resolvedMethod = asExecutable(types.asMemberOf(declaredContainer, subcomponentCreatorMethod)); return Key.builder(resolvedMethod.getReturnType()).build(); }
static MethodSignature forComponentMethod( ComponentMethodDescriptor componentMethod, DeclaredType componentType, DaggerTypes types) { ExecutableType methodType = MoreTypes.asExecutable(types.asMemberOf(componentType, componentMethod.methodElement())); return new AutoValue_MethodSignature( componentMethod.methodElement().getSimpleName().toString(), wrapInEquivalence(methodType.getParameterTypes()), wrapInEquivalence(methodType.getThrownTypes())); }
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()); }
/** 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()); }
checkArgument(!getQualifier(constructorElement).isPresent()); ExecutableType constructorType = MoreTypes.asExecutable(constructorElement.asType()); DeclaredType constructedType = MoreTypes.asDeclared(constructorElement.getEnclosingElement().asType()); types.erasure(resolved), types.erasure(constructedType)); constructorType = MoreTypes.asExecutable(types.asMemberOf(resolved, constructorElement)); constructedType = resolved;
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()))); } return builder .contributionType(ContributionType.fromBindingMethod(method)) .bindingElement(method) .contributingModule(contributedBy) .key(key) .dependencies( dependencyRequestFactory.forRequiredResolvedVariables( method.getParameters(), methodType.getParameterTypes())) .wrappedMapKeyAnnotation(wrapOptionalInEquivalence(getMapKey(method))); }
for (ExecutableElement componentMethod : unimplementedMethods) { ExecutableType resolvedMethod = MoreTypes.asExecutable(types.asMemberOf(declaredComponentType, componentMethod)); ComponentMethodDescriptor componentMethodDescriptor = getDescriptorForComponentMethod(typeElement, kind, componentMethod);
ExecutableElement componentMethod) { ExecutableType resolvedComponentMethod = MoreTypes.asExecutable( types.asMemberOf(MoreTypes.asDeclared(componentElement.asType()), componentMethod)); TypeMirror returnType = resolvedComponentMethod.getReturnType();
.forEachOrdered( method -> { ExecutableType resolvedMethod = asExecutable(types.asMemberOf(subjectType, method)); List<? extends TypeMirror> parameterTypes = resolvedMethod.getParameterTypes(); List<? extends VariableElement> parameters = method.getParameters();
checkArgument(method.getKind().equals(METHOD)); ExecutableType methodType = MoreTypes.asExecutable( types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), method)); ContributionType contributionType = ContributionType.fromBindingMethod(method);
for (ExecutableElement method : elements.getUnimplementedMethods(subject)) { ExecutableType resolvedMethodType = MoreTypes.asExecutable(types.asMemberOf(MoreTypes.asDeclared(subject.asType()), method)); TypeMirror returnType = resolvedMethodType.getReturnType(); switch (method.getParameters().size()) {