Java Code Examples for javax.lang.model.type.ExecutableType#getReturnType()
The following examples show how to use
javax.lang.model.type.ExecutableType#getReturnType() .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: MethodSpec.java From JReFrameworker with MIT License | 6 votes |
/** * Returns a new method spec builder that overrides {@code method} as a member of {@code * enclosing}. This will resolve type parameters: for example overriding {@link * Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T} * parameter will be resolved to {@code Movie}. * * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and * throws declarations. An {@link Override} annotation will be added. * * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately. */ public static Builder overriding( ExecutableElement method, DeclaredType enclosing, Types types) { ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method); List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes(); TypeMirror resolvedReturnType = executableType.getReturnType(); Builder builder = overriding(method); builder.returns(TypeName.get(resolvedReturnType)); for (int i = 0, size = builder.parameters.size(); i < size; i++) { ParameterSpec parameter = builder.parameters.get(i); TypeName type = TypeName.get(resolvedParameterTypes.get(i)); builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build()); } return builder; }
Example 2
Source File: MethodSpec.java From JReFrameworker with MIT License | 6 votes |
/** * Returns a new method spec builder that overrides {@code method} as a member of {@code * enclosing}. This will resolve type parameters: for example overriding {@link * Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T} * parameter will be resolved to {@code Movie}. * * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and * throws declarations. An {@link Override} annotation will be added. * * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately. */ public static Builder overriding( ExecutableElement method, DeclaredType enclosing, Types types) { ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method); List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes(); TypeMirror resolvedReturnType = executableType.getReturnType(); Builder builder = overriding(method); builder.returns(TypeName.get(resolvedReturnType)); for (int i = 0, size = builder.parameters.size(); i < size; i++) { ParameterSpec parameter = builder.parameters.get(i); TypeName type = TypeName.get(resolvedParameterTypes.get(i)); builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build()); } return builder; }
Example 3
Source File: DependencyRequest.java From dagger2-sample with Apache License 2.0 | 6 votes |
DependencyRequest forComponentProductionMethod(ExecutableElement productionMethod, ExecutableType productionMethodType) { checkNotNull(productionMethod); checkNotNull(productionMethodType); checkArgument(productionMethod.getParameters().isEmpty(), "Component production methods must be empty: %s", productionMethod); TypeMirror type = productionMethodType.getReturnType(); Optional<AnnotationMirror> qualifier = InjectionAnnotations.getQualifier(productionMethod); DeclaredType container = getEnclosingType(productionMethod); // Only a component production method can be a request for a ListenableFuture, so we // special-case it here. if (isTypeOf(ListenableFuture.class, type)) { return new AutoValue_DependencyRequest( Kind.FUTURE, keyFactory.forQualifiedType(qualifier, Iterables.getOnlyElement(((DeclaredType) type).getTypeArguments())), productionMethod, container, false /* doesn't allow null */); } else { return newDependencyRequest(productionMethod, type, qualifier, container); } }
Example 4
Source File: DependencyRequest.java From dagger2-sample with Apache License 2.0 | 6 votes |
DependencyRequest forComponentMembersInjectionMethod(ExecutableElement membersInjectionMethod, ExecutableType membersInjectionMethodType) { checkNotNull(membersInjectionMethod); checkNotNull(membersInjectionMethodType); Optional<AnnotationMirror> qualifier = InjectionAnnotations.getQualifier(membersInjectionMethod); checkArgument(!qualifier.isPresent()); TypeMirror returnType = membersInjectionMethodType.getReturnType(); if (returnType.getKind().equals(DECLARED) && MoreTypes.isTypeOf(MembersInjector.class, returnType)) { return new AutoValue_DependencyRequest(Kind.MEMBERS_INJECTOR, keyFactory.forMembersInjectedType( Iterables.getOnlyElement(((DeclaredType) returnType).getTypeArguments())), membersInjectionMethod, getEnclosingType(membersInjectionMethod), false /* doesn't allow null */); } else { return new AutoValue_DependencyRequest(Kind.MEMBERS_INJECTOR, keyFactory.forMembersInjectedType( Iterables.getOnlyElement(membersInjectionMethodType.getParameterTypes())), membersInjectionMethod, getEnclosingType(membersInjectionMethod), false /* doesn't allow null */); } }
Example 5
Source File: MethodSpec.java From javapoet with Apache License 2.0 | 6 votes |
/** * Returns a new method spec builder that overrides {@code method} as a member of {@code * enclosing}. This will resolve type parameters: for example overriding {@link * Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T} * parameter will be resolved to {@code Movie}. * * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and * throws declarations. An {@link Override} annotation will be added. * * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately. */ public static Builder overriding( ExecutableElement method, DeclaredType enclosing, Types types) { ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method); List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes(); List<? extends TypeMirror> resolvedThrownTypes = executableType.getThrownTypes(); TypeMirror resolvedReturnType = executableType.getReturnType(); Builder builder = overriding(method); builder.returns(TypeName.get(resolvedReturnType)); for (int i = 0, size = builder.parameters.size(); i < size; i++) { ParameterSpec parameter = builder.parameters.get(i); TypeName type = TypeName.get(resolvedParameterTypes.get(i)); builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build()); } builder.exceptions.clear(); for (int i = 0, size = resolvedThrownTypes.size(); i < size; i++) { builder.addException(TypeName.get(resolvedThrownTypes.get(i))); } return builder; }
Example 6
Source File: TextDocumentServiceImpl.java From netbeans with Apache License 2.0 | 5 votes |
@Override public CompletionItem createExecutableItem(CompilationInfo info, ExecutableElement elem, ExecutableType type, int substitutionOffset, ReferencesCount referencesCount, boolean isInherited, boolean isDeprecated, boolean inImport, boolean addSemicolon, boolean smartType, int assignToVarOffset, boolean memberRef) { Iterator<? extends VariableElement> it = elem.getParameters().iterator(); Iterator<? extends TypeMirror> tIt = type.getParameterTypes().iterator(); StringBuilder label = new StringBuilder(); String sep = ""; label.append(elem.getSimpleName().toString()); label.append("("); while(it.hasNext() && tIt.hasNext()) { TypeMirror tm = tIt.next(); if (tm == null) { break; } label.append(sep); label.append(Utilities.getTypeName(info, tm, false, elem.isVarArgs() && !tIt.hasNext()).toString()); label.append(' '); label.append(it.next().getSimpleName().toString()); sep = ", "; } label.append(") : "); TypeMirror retType = type.getReturnType(); label.append(Utilities.getTypeName(info, retType, false).toString()); CompletionItem item = new CompletionItem(label.toString()); item.setKind(elementKind2CompletionItemKind(elem.getKind())); item.setInsertText(elem.getSimpleName().toString()); setCompletionData(item, elem); return item; }
Example 7
Source File: ModelUtils.java From FreeBuilder with Apache License 2.0 | 5 votes |
/** * Determines the return type of {@code method}, if called on an instance of type {@code type}. * * <p>For instance, in this example, myY.getProperty() returns List<T>, not T:<pre><code> * interface X<T> { * T getProperty(); * } * @FreeBuilder interface Y<T> extends X<List<T>> { }</code></pre> * * <p>(Unfortunately, a bug in Eclipse prevents us handling these cases correctly at the moment. * javac works fine.) */ public static TypeMirror getReturnType(TypeElement type, ExecutableElement method, Types types) { try { ExecutableType executableType = (ExecutableType) types.asMemberOf((DeclaredType) type.asType(), method); return executableType.getReturnType(); } catch (IllegalArgumentException e) { // Eclipse incorrectly throws an IllegalArgumentException here: // "element is not valid for the containing declared type" // As a workaround for the common case, fall back to the declared return type. return method.getReturnType(); } }
Example 8
Source File: Descriptor.java From auto-matter with Apache License 2.0 | 5 votes |
private void enumerateFields(final Types types) { final List<ExecutableElement> methods = methods(valueTypeElement); for (final Element member : methods) { if (member.getKind() != ElementKind.METHOD || isStaticOrDefault(member)) { continue; } final ExecutableElement method = (ExecutableElement) member; if (member.getSimpleName().toString().equals("builder")) { final TypeMirror returnType = (method).getReturnType(); // TODO: javac does not seem to want to provide the name of the return type if it is not yet present and generic if (!isGeneric && !returnType.toString().equals(concreteBuilderName) && !returnType.toString().equals(fullyQualifiedBuilderName)) { throw new AutoMatterProcessorException( "builder() return type must be " + concreteBuilderName, valueTypeElement); } toBuilder = true; continue; } verifyResolved(method.getReturnType()); fields.add(method); // Resolve inherited members final ExecutableType methodType = (ExecutableType) types.asMemberOf(valueType, member); final TypeMirror fieldType = methodType.getReturnType(); // Resolve types fieldTypes.put(method, TypeName.get(fieldType)); } }
Example 9
Source File: AccessorAttributesCollector.java From immutables with Apache License 2.0 | 5 votes |
static TypeMirror asInheritedMemberReturnType( ProcessingEnvironment processing, TypeElement typeElement, ExecutableElement method) { ExecutableType asMethodOfType = (ExecutableType) processing.getTypeUtils() .asMemberOf((DeclaredType) typeElement.asType(), method); return asMethodOfType.getReturnType(); }
Example 10
Source File: CreateRegistrationProcessor.java From netbeans with Apache License 2.0 | 4 votes |
private void checkMimeLocation(TypeElement clazz, AnnotationMirror am) { for (Entry<? extends ExecutableElement, ? extends AnnotationValue> e : am.getElementValues().entrySet()) { if (!e.getKey().getSimpleName().contentEquals("instanceProviderClass")) continue; TypeMirror ipc = (TypeMirror) e.getValue().getValue(); if (ipc == null || ipc.getKind() != TypeKind.DECLARED) continue; //the compiler should have given the error TypeElement instanceProvider = processingEnv.getElementUtils().getTypeElement("org.netbeans.spi.editor.mimelookup.InstanceProvider"); if (instanceProvider == null) { return ; } ExecutableElement createInstance = null; for (ExecutableElement ee : ElementFilter.methodsIn(instanceProvider.getEnclosedElements())) { if (ee.getSimpleName().contentEquals("createInstance")) { //TODO: check parameters createInstance = ee; break; } } if (createInstance == null) { throw new IllegalStateException("No instanceCreate in InstanceProvider!"); } DeclaredType dipc = (DeclaredType) ipc; Types tu = processingEnv.getTypeUtils(); ExecutableType member = (ExecutableType) tu.asMemberOf(dipc, createInstance); TypeMirror result = member.getReturnType(); TypeMirror jlObject = processingEnv.getElementUtils().getTypeElement("java.lang.Object").asType(); if (!tu.isSameType(tu.erasure(result), jlObject)) { if (!tu.isSubtype(tu.erasure(result), tu.erasure(clazz.asType()))) { processingEnv.getMessager().printMessage(Kind.ERROR, "The InstanceProvider does not create instances of type " + clazz.getQualifiedName(), clazz, am, e.getValue()); } } TypeElement tipc = (TypeElement) dipc.asElement(); if (!tipc.getModifiers().contains(Modifier.PUBLIC)) { processingEnv.getMessager().printMessage(Kind.ERROR, "The InstanceProvider implementation is not public.", clazz, am, e.getValue()); } for (ExecutableElement c : ElementFilter.constructorsIn(tipc.getEnclosedElements())) { if (c.getParameters().isEmpty() && c.getModifiers().contains(Modifier.PUBLIC)) { //OK return; } } processingEnv.getMessager().printMessage(Kind.ERROR, "The InstanceProvider implementation does not provide a public no-arg constructor.", clazz, am, e.getValue()); } }
Example 11
Source File: ComponentProcessor.java From appinventor-extensions with Apache License 2.0 | 4 votes |
private Property executableElementToProperty(Element element, String componentInfoName) { String propertyName = element.getSimpleName().toString(); SimpleProperty simpleProperty = element.getAnnotation(SimpleProperty.class); if (!(element.asType() instanceof ExecutableType)) { throw new RuntimeException("element.asType() is not an ExecutableType for " + propertyName); } // Use Javadoc for property unless description is set to a non-empty string. String description = elementUtils.getDocComment(element); String longDescription = description; if (!simpleProperty.description().isEmpty()) { description = simpleProperty.description(); } if (description == null) { description = ""; } // Read only until the first javadoc parameter description = description.split("[^\\\\][@{]")[0].trim(); Property property = new Property(propertyName, description, longDescription, simpleProperty.category(), simpleProperty.userVisible(), elementUtils.isDeprecated(element)); // Get parameters to tell if this is a getter or setter. ExecutableType executableType = (ExecutableType) element.asType(); List<? extends TypeMirror> parameters = executableType.getParameterTypes(); // Check if it is a setter or getter, and set the property's readable, writable, // and type fields appropriately. TypeMirror typeMirror; if (parameters.size() == 0) { // It is a getter. property.readable = true; typeMirror = executableType.getReturnType(); if (typeMirror.getKind().equals(TypeKind.VOID)) { throw new RuntimeException("Property method is void and has no parameters: " + propertyName); } if (element.getAnnotation(IsColor.class) != null) { property.color = true; } } else { // It is a setter. property.writable = true; if (parameters.size() != 1) { throw new RuntimeException("Too many parameters for setter for " + propertyName); } typeMirror = parameters.get(0); for (VariableElement ve : ((ExecutableElement) element).getParameters()) { if (ve.getAnnotation(IsColor.class) != null) { property.color = true; } } } // Use typeMirror to set the property's type. if (!typeMirror.getKind().equals(TypeKind.VOID)) { property.type = typeMirror.toString(); updateComponentTypes(typeMirror); } property.componentInfoName = componentInfoName; return property; }
Example 12
Source File: ComponentDescriptor.java From dagger2-sample with Apache License 2.0 | 4 votes |
private ComponentMethodDescriptor getDescriptorForComponentMethod(TypeElement componentElement, Kind componentKind, 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 new AutoValue_ComponentDescriptor_ComponentMethodDescriptor( ComponentMethodKind.PROVISON, Optional.of(dependencyRequestFactory.forComponentProvisionMethod(componentMethod, resolvedComponentMethod)), componentMethod); } else if (MoreTypes.isTypeOf(MembersInjector.class, returnType)) { return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor( ComponentMethodKind.MEMBERS_INJECTION, Optional.of(dependencyRequestFactory.forComponentMembersInjectionMethod( componentMethod, resolvedComponentMethod)), componentMethod); } else if (getAnnotationMirror(MoreTypes.asElement(returnType), Subcomponent.class) .isPresent()) { return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor( ComponentMethodKind.SUBCOMPONENT, Optional.<DependencyRequest>absent(), componentMethod); } } // a typical provision method if (componentMethod.getParameters().isEmpty() && !componentMethod.getReturnType().getKind().equals(VOID)) { switch (componentKind) { case COMPONENT: return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor( ComponentMethodKind.PROVISON, Optional.of(dependencyRequestFactory.forComponentProvisionMethod(componentMethod, resolvedComponentMethod)), componentMethod); case PRODUCTION_COMPONENT: return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor( ComponentMethodKind.PRODUCTION, Optional.of(dependencyRequestFactory.forComponentProductionMethod(componentMethod, resolvedComponentMethod)), componentMethod); default: throw new AssertionError(); } } List<? extends TypeMirror> parameterTypes = resolvedComponentMethod.getParameterTypes(); if (parameterTypes.size() == 1 && (returnType.getKind().equals(VOID) || MoreTypes.equivalence().equivalent(returnType, parameterTypes.get(0)))) { return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor( ComponentMethodKind.MEMBERS_INJECTION, Optional.of(dependencyRequestFactory.forComponentMembersInjectionMethod( componentMethod, resolvedComponentMethod)), componentMethod); } throw new IllegalArgumentException("not a valid component method: " + componentMethod); }
Example 13
Source File: ComponentMethodDescriptor.java From bullet with Apache License 2.0 | 4 votes |
static Optional<ComponentMethodDescriptor> forComponentMethod(Types types, DeclaredType componentElement, ExecutableElement componentMethod) { // Using same algorithm as Dagger's ComponentDescriptor#getDescriptorForComponentMethod ExecutableType resolvedComponentMethod = MoreTypes.asExecutable(types.asMemberOf(componentElement, componentMethod)); TypeMirror returnType = resolvedComponentMethod.getReturnType(); if (returnType.getKind() == TypeKind.DECLARED) { if (MoreTypes.isTypeOf(Provider.class, returnType) || MoreTypes.isTypeOf(Lazy.class, returnType)) { return methodDescriptor( ComponentMethodKind.PROVIDER_OR_LAZY, MoreTypes.asDeclared(MoreTypes.asDeclared(returnType).getTypeArguments().get(0)), componentMethod); } else if (MoreTypes.isTypeOf(MembersInjector.class, returnType)) { return methodDescriptor( ComponentMethodKind.MEMBERS_INJECTOR, MoreTypes.asDeclared(MoreTypes.asDeclared(returnType).getTypeArguments().get(0)), componentMethod); } else if (MoreElements.getAnnotationMirror(types.asElement(returnType), Subcomponent.class).isPresent()) { // Ignore subcomponent methods return Optional.absent(); } } if (resolvedComponentMethod.getParameterTypes().isEmpty() && resolvedComponentMethod.getReturnType().getKind() == TypeKind.DECLARED) { return methodDescriptor( ComponentMethodKind.SIMPLE_PROVISION, MoreTypes.asDeclared(returnType), componentMethod); } List<? extends TypeMirror> parameterTypes = resolvedComponentMethod.getParameterTypes(); if (parameterTypes.size() == 1 && parameterTypes.get(0).getKind() == TypeKind.DECLARED && (returnType.getKind().equals(TypeKind.VOID) || types.isSameType(returnType, parameterTypes.get(0)))) { return methodDescriptor( ComponentMethodKind.SIMPLE_MEMBERS_INJECTION, MoreTypes.asDeclared(parameterTypes.get(0)), componentMethod); } // Let Dagger do the validation return Optional.absent(); }
Example 14
Source File: OptionProcessor.java From bazel with Apache License 2.0 | 4 votes |
private void checkProvidedConverter( VariableElement optionField, ImmutableList<TypeMirror> acceptedConverterReturnTypes, TypeElement converterElement) throws OptionProcessorException { if (converterElement.getModifiers().contains(Modifier.ABSTRACT)) { throw new OptionProcessorException( optionField, "The converter type %s must be a concrete type", converterElement.asType()); } DeclaredType converterType = (DeclaredType) converterElement.asType(); // Unfortunately, for provided classes, we do not have access to the compiled convert // method at this time, and cannot check that the default value is parseable. We will // instead check that T of Converter<T> matches the option's type, but this is all we can // do. List<ExecutableElement> methodList = elementUtils.getAllMembers(converterElement).stream() .filter(element -> element.getKind() == ElementKind.METHOD) .map(methodElement -> (ExecutableElement) methodElement) .filter(methodElement -> methodElement.getSimpleName().contentEquals("convert")) .filter( methodElement -> methodElement.getParameters().size() == 1 && typeUtils.isSameType( methodElement.getParameters().get(0).asType(), elementUtils.getTypeElement(String.class.getCanonicalName()).asType())) .collect(Collectors.toList()); // Check that there is just the one method if (methodList.size() != 1) { throw new OptionProcessorException( optionField, "Converter %s has methods 'convert(String)': %s", converterElement, methodList.stream().map(Object::toString).collect(Collectors.joining(", "))); } ExecutableType convertMethodType = (ExecutableType) typeUtils.asMemberOf(converterType, methodList.get(0)); TypeMirror convertMethodResultType = convertMethodType.getReturnType(); // Check that the converter's return type is in the accepted list. for (TypeMirror acceptedConverterReturnType : acceptedConverterReturnTypes) { if (typeUtils.isAssignable(convertMethodResultType, acceptedConverterReturnType)) { return; // This one passes the test. } } throw new OptionProcessorException( optionField, "Type of field (%s) must be assignable from the converter's return type (%s)", acceptedConverterReturnTypes.get(0), convertMethodResultType); }