@Override public DeclaredType getAnnotationType() { return MoreTypes.asDeclared(annotationType.asType()); }
private ElementKind unwrappedValueKind(TypeElement mapKeyAnnotationType) { DeclaredType unwrappedMapKeyType = getUnwrappedMapKeyType(MoreTypes.asDeclared(mapKeyAnnotationType.asType()), types); return unwrappedMapKeyType.asElement().getKind(); } }
private MethodSpec emptyComponentMethod(TypeElement typeElement, ExecutableElement baseMethod) { return MethodSpec.overriding(baseMethod, MoreTypes.asDeclared(typeElement.asType()), types) .build(); }
private DeclaredType parentType() { return asDeclared(parent.get().graph.componentTypeElement().asType()); }
@Override public DeclaredType visitPrimitive(PrimitiveType t, Void p) { return MoreTypes.asDeclared(types.boxedClass(t).asType()); }
private TypeMirror unwrapTypeOrDefault(TypeMirror type, TypeMirror defaultType) { DeclaredType declaredType = MoreTypes.asDeclared(type); TypeElement typeElement = MoreElements.asType(declaredType.asElement()); checkArgument( !typeElement.getTypeParameters().isEmpty(), "%s does not have a type parameter", typeElement.getQualifiedName()); return getOnlyElement(declaredType.getTypeArguments(), defaultType); }
/** Returns the enclosed types annotated with the given annotation. */ static ImmutableList<DeclaredType> enclosedAnnotatedTypes( TypeElement typeElement, Class<? extends Annotation> annotation) { final ImmutableList.Builder<DeclaredType> builders = ImmutableList.builder(); for (TypeElement element : typesIn(typeElement.getEnclosedElements())) { if (MoreElements.isAnnotationPresent(element, annotation)) { builders.add(MoreTypes.asDeclared(element.asType())); } } return builders.build(); }
private static Optional<TypeMirror> unwrapListenableFuture( ValidationReport.Builder<ExecutableElement> reportBuilder, TypeMirror type) { if (MoreTypes.isType(type) && MoreTypes.isTypeOf(ListenableFuture.class, type)) { DeclaredType declaredType = MoreTypes.asDeclared(type); if (declaredType.getTypeArguments().isEmpty()) { reportBuilder.addError("@Produces methods cannot return a raw ListenableFuture"); return Optional.empty(); } else { return Optional.of((TypeMirror) getOnlyElement(declaredType.getTypeArguments())); } } return Optional.of(type); } }
private MethodSignature getMethodSignature(ComponentMethodDescriptor method) { return MethodSignature.forComponentMethod( method, MoreTypes.asDeclared(graph.componentTypeElement().asType()), types); }
Key forProductionComponentMethod(ExecutableElement componentMethod) { checkArgument(componentMethod.getKind().equals(METHOD)); TypeMirror returnType = componentMethod.getReturnType(); TypeMirror keyType = isFutureType(returnType) ? getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments()) : returnType; return forMethod(componentMethod, keyType); }
/** * 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 protected MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement) { ExecutableElement supertypeMethod = creatorDescriptor.elementForRequirement(requirement); MethodSpec.Builder method = MethodSpec.overriding( supertypeMethod, asDeclared(creatorDescriptor.typeElement().asType()), types); if (!supertypeMethod.getReturnType().getKind().equals(TypeKind.VOID)) { // Take advantage of covariant returns so that we don't have to worry about setter methods // that return type variables. method.returns(className); } return method; } }
/** 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 TypeName constructorTypeName(ClassName requestingClass) { DeclaredType type = MoreTypes.asDeclared(provisionBinding.key().type()); TypeName typeName = TypeName.get(type); if (type.getTypeArguments() .stream() .allMatch(t -> isTypeAccessibleFrom(t, requestingClass.packageName()))) { return typeName; } return rawTypeName(typeName); }
/** * 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 {@link OptionalType} for {@code type}. * * @throws IllegalArgumentException if {@code type} is not an {@code Optional} type */ static OptionalType from(TypeMirror type) { checkArgument(isOptional(type), "%s must be an Optional", type); return new AutoValue_OptionalType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type))); }
/** * Returns a {@link MapType} for {@code type}. * * @throws IllegalArgumentException if {@code type} is not a {@link Map} type */ static MapType from(TypeMirror type) { checkArgument(isMap(type), "%s is not a Map", type); return new AutoValue_MapType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type))); }
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); }
/** Returns the implementation of a component method. */ MethodSpec getComponentMethod(ComponentMethodDescriptor componentMethod) { checkArgument(componentMethod.dependencyRequest().isPresent()); BindingRequest request = bindingRequest(componentMethod.dependencyRequest().get()); return MethodSpec.overriding( componentMethod.methodElement(), MoreTypes.asDeclared(graph.componentTypeElement().asType()), types) .addCode( getBindingExpression(request) .getComponentMethodImplementation(componentMethod, componentImplementation)) .build(); }
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()); }