Java Code Examples for javax.lang.model.type.ExecutableType#getReturnType()

/**
 * 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;
}
 

/**
 * 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;
}
 

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);
  }
}
 

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 */);
  }
}
 

/**
 * 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;
}
 

@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;
}
 

/**
 * 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&lt;T&gt;, not T:<pre><code>
 *    interface X&lt;T&gt; {
 *      T getProperty();
 *    }
 *    &#64;FreeBuilder interface Y&lt;T&gt; extends X&lt;List&lt;T&gt;&gt; { }</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();
  }
}
 

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));
  }
}
 

static TypeMirror asInheritedMemberReturnType(
    ProcessingEnvironment processing,
    TypeElement typeElement,
    ExecutableElement method) {
  ExecutableType asMethodOfType =
      (ExecutableType) processing.getTypeUtils()
          .asMemberOf((DeclaredType) typeElement.asType(), method);

  return asMethodOfType.getReturnType();
}
 

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());
    }
}
 

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;
}
 

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);
}
 

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();
}
 

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);
}