@Override protected TypeName defaultAction(TypeMirror typeMirror, Void v) { return TypeName.get(typeMirror); } }, null);
private TypeName argToType(Object o) { if (o instanceof TypeName) return (TypeName) o; if (o instanceof TypeMirror) return TypeName.get((TypeMirror) o); if (o instanceof Element) return TypeName.get(((Element) o).asType()); if (o instanceof Type) return TypeName.get((Type) o); throw new IllegalArgumentException("expected type but was " + o); }
/** Returns a type name equivalent to {@code mirror}. */ public static TypeName get(TypeMirror mirror) { return get(mirror, new LinkedHashMap<>()); }
/** Returns a type name equivalent to {@code type}. */ public static TypeName get(Type type) { return get(type, new LinkedHashMap<>()); }
static List<TypeName> list(Type[] types, Map<Type, TypeVariableName> map) { List<TypeName> result = new ArrayList<>(types.length); for (Type type : types) { result.add(get(type, map)); } return result; }
@Nullable static TypeName getReturnType(Elements elements, Element typeElement) { TypeMirror typeMirror = ProcessorUtils.getAnnotationParameter( elements, typeElement, Event.class, "returnType", TypeMirror.class); return typeMirror != null ? TypeName.get(typeMirror) : null; } }
@NonNull public Element fromDelegateConstructor(@NonNull ExecutableElement constructor, boolean hasContextParameter) { return new BuilderElement.Delegate(TypeName.get(constructor.getEnclosingElement().asType()), hasContextParameter); } }
/** Returns an array type whose elements are all instances of {@code componentType}. */ public static ArrayTypeName of(Type componentType) { return of(TypeName.get(componentType)); }
@NonNull public Element fromTransformDelegateMethod(@NonNull ExecutableElement method, Element transform) { if (transform instanceof TransformedField.Transformable) { return new TransformedField(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), (TransformedField.Transformable) transform); } return transform; }
public static Builder builder(Type type, String name, Modifier... modifiers) { return builder(TypeName.get(type), name, modifiers); }
@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)); }
@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)); }
static Builder newBuilder(TypeElement enclosingElement) { TypeMirror typeMirror = enclosingElement.asType(); boolean isView = isSubtypeOfType(typeMirror, VIEW_TYPE); boolean isActivity = isSubtypeOfType(typeMirror, ACTIVITY_TYPE); boolean isDialog = isSubtypeOfType(typeMirror, DIALOG_TYPE); TypeName targetType = TypeName.get(typeMirror); if (targetType instanceof ParameterizedTypeName) { targetType = ((ParameterizedTypeName) targetType).rawType; } String packageName = getPackage(enclosingElement).getQualifiedName().toString(); String className = enclosingElement.getQualifiedName().toString().substring( packageName.length() + 1).replace('.', '$'); ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding"); boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL); return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog); }
/** Returns type variable equivalent to {@code element}. */ public static TypeVariableName get(TypeParameterElement element) { String name = element.getSimpleName().toString(); List<? extends TypeMirror> boundsMirrors = element.getBounds(); List<TypeName> boundsTypeNames = new ArrayList<>(); for (TypeMirror typeMirror : boundsMirrors) { boundsTypeNames.add(TypeName.get(typeMirror)); } return TypeVariableName.of(name, boundsTypeNames); }
private void createBuilderInterface(@NonNull List<Element> elements) throws IOException { final TypeSpec.Builder interfaceBuilder = TypeSpec.interfaceBuilder(builderVisibleName) .addModifiers(Modifier.PUBLIC) .addSuperinterface(ConfigurationBuilder.class); final TypeName baseAnnotation = TypeName.get(this.baseAnnotation.asType()); Strings.addClassJavadoc(interfaceBuilder, baseAnnotation); ClassName builder = ClassName.get(PACKAGE, builderVisibleName); elements.stream().filter(BuilderElement.Interface.class::isInstance).map(BuilderElement.Interface.class::cast) .forEach(element -> element.addToBuilderInterface(interfaceBuilder, builder)); Strings.writeClass(processingEnv.getFiler(), interfaceBuilder.build()); }
@NonNull public Element fromAnnotationMethod(@NonNull ExecutableElement method) { final Pair<List<AnnotationSpec>, Set<ClassName>> annotations = getAnnotations(method); return new AnnotationField.Normal(method.getSimpleName().toString(), TypeName.get(method.getReturnType()), annotations.getLeft(), annotations.getRight(), method.getDefaultValue(), elements.getDocComment(method)); }
private static TypeName[] getBounds(TypeParameterElement typeParameterElement) { final TypeName[] bounds = new TypeName[typeParameterElement.getBounds().size()]; for (int i = 0, size = typeParameterElement.getBounds().size(); i < size; i++) { bounds[i] = TypeName.get(typeParameterElement.getBounds().get(i)); } return bounds; } }
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())); }
public static ParameterSpec get(VariableElement element) { TypeName type = TypeName.get(element.asType()); String name = element.getSimpleName().toString(); return ParameterSpec.builder(type, name) .addModifiers(element.getModifiers()) .build(); }
protected static List<ParameterSpec> buildParamSpecs(List<? extends VariableElement> params) { List<ParameterSpec> result = new ArrayList<>(); for (VariableElement param : params) { Builder builder = ParameterSpec.builder(TypeName.get(param.asType()), param.getSimpleName().toString()); for (AnnotationMirror annotation : param.getAnnotationMirrors()) { builder.addAnnotation(AnnotationSpec.get(annotation)); } result.add(builder.build()); } return result; }