@Override public List<? extends TypeParameterElement> getTypeParameters() { List<? extends TypeParameterElement> tps = typeParameters; if (tps == null) { tps = delegate.getTypeParameters(); typeParameters = tps; } return tps; }
private boolean shouldConsideredAsTypeUsage(ExecutableElement method) { return method.getTypeParameters().isEmpty() && !method.getModifiers().contains(Modifier.PRIVATE) && !method.getModifiers().contains(Modifier.STATIC); }
private boolean isSimpleAccessor(ExecutableElement method) { return method.getParameters().isEmpty() && method.getThrownTypes().isEmpty() && method.getTypeParameters().isEmpty() && method.getReturnType().getKind() != TypeKind.VOID; }
@NonNull public Element fromBuilderDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
@NonNull public Element fromConfigDelegateMethod(@NonNull ExecutableElement method) { return new DelegateMethod.Config(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), getAnnotations(method).getLeft(), method.getParameters().stream().map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.getSimpleName().toString()).build()).collect(Collectors.toList()), method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()), method.getModifiers(), elements.getDocComment(method)); }
public List<TypeParameterModel> getTypeParameters() { return executableElement.getTypeParameters().stream() .map(typeParam -> new TypeParameterModel(elementUtils, typeParam.asType())) .collect(toList()); }
public static MethodSpec.Builder overriding(ExecutableElement method) { return MethodSpec.methodBuilder(method.getSimpleName().toString()) .addAnnotation(Override.class) .addModifiers(method.getModifiers().stream().filter(modifier -> modifier != Modifier.ABSTRACT).collect(Collectors.toList())) .returns(TypeName.get(method.getReturnType())) .varargs(method.isVarArgs()) .addExceptions(method.getThrownTypes().stream().map(TypeName::get).collect(Collectors.toList())) .addTypeVariables(method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList())) .addParameters(method.getParameters().stream().map(element -> ParameterSpec.get(element).toBuilder() .addAnnotations(element.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(Collectors.toList())).build()).collect(Collectors.toList())); }
@Override default List<? extends TypeParameterElement> getTypeParameters() { return getDelegate().getTypeParameters(); }
static List<TypeVariableName> getTypeVariables(ExecutableElement method) { final List<TypeVariableName> typeVariables = new ArrayList<>(); for (TypeParameterElement typeParameterElement : method.getTypeParameters()) { typeVariables.add( TypeVariableName.get( typeParameterElement.getSimpleName().toString(), getBounds(typeParameterElement))); } return typeVariables; }
private void addMethods(TypeElement interfaceClazz, TypeSpec.Builder classBuilder) { List<? extends Element> elements = interfaceClazz.getEnclosedElements(); if (elements != null && !elements.isEmpty()) { for (Element e : elements) { if (ElementKind.METHOD.equals(e.getKind())) { ExecutableElement method = (ExecutableElement) e; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.getSimpleName().toString() + ASYNC) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT).returns(ResponseFuture.class) .addTypeVariables(getTypeNames(method.getTypeParameters())); // add method params List<? extends VariableElement> vars = method.getParameters(); for (VariableElement var : vars) { methodBuilder.addParameter(ParameterSpec.builder(TypeName.get(var.asType()), var.getSimpleName().toString()) .build()); } classBuilder.addMethod(methodBuilder.build()); } } } }
private void debugMethod(ExecutableElement method) { logger.finest(format(" method: simpleName=%s, asType=%s, varargs=%s, returnType=%s, enclosingElement=%s, params=%s, typeParams=%s", method.getSimpleName(), method.asType(), method.isVarArgs(), method.getReturnType(), method.getEnclosingElement(), method.getParameters(), method.getTypeParameters())); for (VariableElement variable : method.getParameters()) { logger.finest(format(" variable: name=%s, annotationMirrors=%s, @Option=%s, @Parameters=%s", variable.getSimpleName(), variable.getAnnotationMirrors(), variable.getAnnotation( Option.class), variable.getAnnotation(Parameters.class))); } }
/** * Return true if the possibleBuilderMethod matches the * Style#attributeBuilder() and returns a class. * * TODO: may need to make this return true if the return type is an interface too... * * @param possibleBuilderMethod executableElement */ private static boolean isPossibleBuilderMethod(Element possibleBuilderMethod, boolean onValueType, ValueAttribute valueAttribute) { if (possibleBuilderMethod.getKind() == ElementKind.METHOD) { if (!valueAttribute.containingType.names().possibleAttributeBuilder(possibleBuilderMethod.getSimpleName())) { return false; } ExecutableElement candidateMethod = (ExecutableElement) possibleBuilderMethod; TypeKind kind = candidateMethod.getReturnType().getKind(); return possibleBuilderMethod.getModifiers().containsAll( Arrays.asList(Modifier.STATIC, Modifier.PUBLIC)) && candidateMethod.getParameters().isEmpty() && candidateMethod.getReturnType().getKind() == TypeKind.DECLARED && !kind.isPrimitive() && kind != TypeKind.ARRAY; } else if (!onValueType && possibleBuilderMethod.getKind() == ElementKind.CONSTRUCTOR) { if (!valueAttribute.containingType.names().newTokenInAttributeBuilder()) { return false; } ExecutableElement candidateConstructor = (ExecutableElement) possibleBuilderMethod; return candidateConstructor.getModifiers().contains(Modifier.PUBLIC) && candidateConstructor.getTypeParameters().isEmpty(); } return false; }
methodBuilder.addModifiers(modifiers); for (TypeParameterElement typeParameterElement : method.getTypeParameters()) { TypeVariable var = (TypeVariable) typeParameterElement.asType(); methodBuilder.addTypeVariable(TypeVariableName.get(var));
/** * Returns true if there's a public way to build the value type with an instance no-arg method. * * @param attribute value attribute to check. * @param possibleBuildMethod method which matches {@link StyleMirror#attributeBuilder()} * @return true if this is the possibleBuildMethod can build the value type. */ private static boolean isPossibleBuildMethod(ValueAttribute attribute, Element possibleBuildMethod) { if (possibleBuildMethod.getKind() != ElementKind.METHOD) { return false; } if (!attribute.containingType.names().possibleAttributeBuilder(possibleBuildMethod.getSimpleName())) { return false; } Types typeUtils = attribute.containingType.constitution.protoclass() .environment() .processing() .getTypeUtils(); ExecutableElement candidateBuildMethod = (ExecutableElement) possibleBuildMethod; return !candidateBuildMethod.getModifiers().contains(Modifier.STATIC) && candidateBuildMethod.getModifiers().contains(Modifier.PUBLIC) && candidateBuildMethod.getTypeParameters().isEmpty() && candidateBuildMethod.getReturnType().getKind() == TypeKind.DECLARED && typeUtils.isSameType(candidateBuildMethod.getReturnType(), attribute.containedTypeElement.asType()); }
static MethodSpec.Builder overriding(ExecutableElement method) { String methodName = method.getSimpleName().toString(); MethodSpec.Builder builder = MethodSpec.methodBuilder(methodName) .addAnnotation(Override.class); Set<Modifier> modifiers = method.getModifiers(); modifiers = new LinkedHashSet<>(modifiers); modifiers.remove(Modifier.ABSTRACT); Modifier defaultModifier = null; // Modifier.DEFAULT doesn't exist until Java 8. try { defaultModifier = Modifier.valueOf("DEFAULT"); } catch (IllegalArgumentException e) { // Ignored. } modifiers.remove(defaultModifier); builder = builder.addModifiers(modifiers); for (TypeParameterElement typeParameterElement : method.getTypeParameters()) { TypeVariable var = (TypeVariable) typeParameterElement.asType(); builder = builder.addTypeVariable(TypeVariableName.get(var)); } builder = builder.returns(TypeName.get(method.getReturnType())) .addParameters(getParameters(method)) .varargs(method.isVarArgs()); for (TypeMirror thrownType : method.getThrownTypes()) { builder = builder.addException(TypeName.get(thrownType)); } return builder; }
Map<String, List<AbstractJClass>> methodTypes = new LinkedHashMap<>(); for (TypeParameterElement typeParameter : executableElement.getTypeParameters()) { List<? extends TypeMirror> bounds = typeParameter.getBounds();
private boolean processBuilderIsInitMethod(ExecutableElement method) { if (isInit != null) { reporter.withElement(method) .error("@Encoding.IsInit duplicate is init method '%s'. Cannot have more than one", method.getSimpleName()); return true; } if (typesReader.get(method.getReturnType()) != Type.Primitive.BOOLEAN) { reporter.withElement(method) .error("@Encoding.IsInit method '%s' must return boolean if ", method.getSimpleName()); return true; } if (!method.getTypeParameters().isEmpty()) { reporter.withElement(method) .error("@Encoding.IsInit method '%s' cannot have type parameters", method.getSimpleName()); return true; } if (!method.getParameters().isEmpty()) { reporter.withElement(method) .error("@Encoding.IsInit method '%s' cannot have parameters", method.getSimpleName()); return true; } List<EncodedElement> captured = new ArrayList<>(); boolean result = processGenericEncodedMethod(method, captured, Tag.IS_INIT, Tag.BUILDER, Tag.PRIVATE); if (result) { this.isInit = captured.get(0); } return result; }
private TypeExtractor processTypeParameters(ExecutableElement method, EncodedElement.Builder builder) { boolean isStatic = method.getModifiers().contains(Modifier.STATIC); TypeExtractor typesReader = isStatic ? new TypeExtractor(types, method) : this.typesReader; for (TypeParameterElement p : method.getTypeParameters()) { String name = p.getSimpleName().toString(); ImmutableList<Defined> bounds = typesReader.getDefined(p.getBounds()); if (!isStatic) { typesReader = typesReader.withParameter(name, bounds); } builder.addTypeParams(new EncodedElement.TypeParam.Builder() .name(name) .addAllBounds(bounds) .build()); } builder.typeParameters(typesReader.parameters); return typesReader; }
List<? extends TypeParameterElement> typeParameters = instanceMethod.getTypeParameters(); for (TypeParameterElement typeParameterElement : typeParameters) { methodSpecBuilder.addTypeVariable(
List<? extends TypeParameterElement> typeParameters = staticMethod.getTypeParameters(); for (TypeParameterElement typeParameterElement : typeParameters) { methodSpecBuilder.addTypeVariable(