@Override public boolean isVarArgs() { return delegate.isVarArgs(); }
/** * Get information about constructors of the original class so we can duplicate them in the * generated class and call through to super with the proper parameters */ protected static List<ConstructorInfo> getClassConstructors(TypeElement classElement) { List<ConstructorInfo> constructors = new ArrayList<>(2); for (Element subElement : classElement.getEnclosedElements()) { if (subElement.getKind() == ElementKind.CONSTRUCTOR && !subElement.getModifiers().contains(Modifier.PRIVATE)) { ExecutableElement constructor = ((ExecutableElement) subElement); List<? extends VariableElement> params = constructor.getParameters(); constructors.add(new ConstructorInfo(subElement.getModifiers(), buildParamSpecs(params), constructor.isVarArgs())); } } return constructors; }
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 boolean isVarArgs() { return getDelegate().isVarArgs(); }
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))); } }
/** * Get information about methods returning class type of the original class so we can duplicate * them in the generated class for chaining purposes */ protected void collectMethodsReturningClassType(TypeElement modelClass, Types typeUtils) { TypeElement clazz = modelClass; while (clazz.getSuperclass().getKind() != TypeKind.NONE) { for (Element subElement : clazz.getEnclosedElements()) { Set<Modifier> modifiers = subElement.getModifiers(); if (subElement.getKind() == ElementKind.METHOD && !modifiers.contains(Modifier.PRIVATE) && !modifiers.contains(Modifier.FINAL) && !modifiers.contains(Modifier.STATIC)) { TypeMirror methodReturnType = ((ExecutableType) subElement.asType()).getReturnType(); if (methodReturnType.equals(clazz.asType()) || typeUtils.isSubtype(clazz.asType(), methodReturnType)) { ExecutableElement castedSubElement = ((ExecutableElement) subElement); List<? extends VariableElement> params = castedSubElement.getParameters(); String methodName = subElement.getSimpleName().toString(); if (methodName.equals(RESET_METHOD) && params.isEmpty()) { continue; } methodsReturningClassType.add(new MethodInfo(methodName, modifiers, buildParamSpecs(params), castedSubElement.isVarArgs())); } } } clazz = (TypeElement) typeUtils.asElement(clazz.getSuperclass()); } }
static boolean isValid(ExecutableElement elem, Messager messager) { return ensure(elem, doesNotThrow(elem), messager, () -> "@" + "Unapply method should not throw (checked) exceptions.") && ensure(elem, !elem.isDefault(), messager, () -> "@" + "Unapply method needs to be declared in a class, not an interface.") && ensure(elem, !elem.isVarArgs(), messager, () -> "@" + "Unapply method has varargs.") && ensure(elem, elem.getParameters().size() == 1, messager, () -> "Unapply method must have exactly one parameter of the object to be deconstructed.") && ensure(elem, elem.getParameters().get(0).asType().getKind() == TypeKind.DECLARED, messager, () -> "Unapply method parameter must be a declared type.") && ensure(elem, elem.getReturnType().toString().startsWith("io.vavr.Tuple"), messager, () -> "Return type of unapply method must be a Tuple.") && ensure(elem, !elem.getReturnType().toString().endsWith("Tuple"), messager, () -> "Return type is no Tuple implementation.") && ensure(elem, hasAll(elem, STATIC), messager, () -> "Unapply method needs to be static.") && ensure(elem, hasNone(elem, PRIVATE, PROTECTED, ABSTRACT), messager, () -> "Unapply method may not be private or protected."); }
private List<Param> getParameters(final TypeExtractor typesReader, ExecutableElement method) { List<Param> result = new ArrayList<>(); for (VariableElement v : method.getParameters()) { result.add(Param.of( v.getSimpleName().toString(), typesReader.get(v.asType()))); } if (!result.isEmpty() && method.isVarArgs()) { Param last = Iterables.getLast(result); Type type = last.type().accept(new Type.Transformer() { @Override public Type array(Array array) { return typesReader.factory.varargs(array.element); } }); result.set(result.size() - 1, Param.of(last.name(), type)); } return result; }
public static Set<Parameter> of(final ProcessingEnvironment processingEnv, final ExecutableElement method) { final Types types = processingEnv.getTypeUtils(); final Set<Parameter> result = new LinkedHashSet<>(); final List<? extends VariableElement> params = method.getParameters(); int index = 0; for (VariableElement param : params) { final TypeElement formatClassType = ElementHelper.getClassAnnotationValue(param, FormatWith.class); final String formatClass = formatClassType == null ? null : formatClassType.getQualifiedName().toString(); final String qualifiedType; if (param.asType().getKind().isPrimitive()) { qualifiedType = param.asType().toString(); } else { switch ((param.asType().getKind())) { case ARRAY: qualifiedType = param.asType().toString().replace("[]", ""); break; default: qualifiedType = types.asElement(param.asType()).toString(); break; } } if (method.isVarArgs()) { result.add(new AptParameter(processingEnv, qualifiedType, param, formatClass, (++index == params.size()))); } else { result.add(new AptParameter(processingEnv, qualifiedType, param, formatClass, false)); } } return result; }
.addModifiers(Modifier.PUBLIC) .addJavadoc(processorUtil.generateSeeMethodJavadoc(element)) .varargs(element.isVarArgs()) .returns(containingClassName) .addAnnotation(
methodBuilder.varargs(method.isVarArgs());
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; }
boolean varParam = i == executableElement.getParameters().size() - 1 && executableElement.isVarArgs(); addParamToMethod(method, parameter, JMod.FINAL, actualTypes, varParam); i++;
if (m.isVarArgs() && (j == parameters.size() - 1)) {// replace T[] with T... param = param.replaceFirst("\\[\\]$", "...");
.addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addJavadoc(processorUtil.generateSeeMethodJavadoc(instanceMethod)) .varargs(instanceMethod.isVarArgs()) .returns(glideOptionsName);
&& methodToOverride.isVarArgs()) { result .addModifiers(Modifier.FINAL)
if (methodToOverride.isVarArgs()) { builder = builder .addModifiers(Modifier.FINAL)
@Override public boolean isVarArgs() { return executableElement.isVarArgs(); }
public int getVarArgsIndex(int parameterIndex) { if (method.isVarArgs()) { int index = parameterIndex - (method.getParameters().size() - 1); return index; } return -1; }
public MethodInfoExecutableElementCore build() { return new MethodInfoExecutableElementCore( typeParameterInfoMap, accessInfo(), modifierInfoSet(), name(), element.isVarArgs()); }