shade.polaris.com.google.auto.value.processor.BuilderSpec Maven / Gradle / Ivy

We currently impose that there cannot be more than one such method. */ ImmutableSet toBuilderMethods( Types typeUtils, TypeElement autoValueType, Set abstractMethods) { List builderTypeParamNames = builderTypeElement.getTypeParameters().stream() .map(e -> e.getSimpleName().toString()) .collect(toList()); DeclaredType autoValueTypeMirror = MoreTypes.asDeclared(autoValueType.asType()); ImmutableSet.Builder methods = ImmutableSet.builder(); for (ExecutableElement method : abstractMethods) { if (!method.getParameters().isEmpty()) { continue; } ExecutableType methodMirror = MoreTypes.asExecutable(typeUtils.asMemberOf(autoValueTypeMirror, method)); TypeMirror returnTypeMirror = methodMirror.getReturnType(); if (builderTypeElement.equals(typeUtils.asElement(returnTypeMirror))) { methods.add(method); DeclaredType returnType = MoreTypes.asDeclared(returnTypeMirror); List typeArguments = returnType.getTypeArguments().stream() .filter(t -> t.getKind().equals(TypeKind.TYPEVAR)) .map(t -> typeUtils.asElement(t).getSimpleName().toString()) .collect(toList()); if (!builderTypeParamNames.equals(typeArguments)) { errorReporter.reportError( method, "[AutoValueBuilderConverterReturn] Builder converter method should return %s%s", builderTypeElement, TypeSimplifier.actualTypeParametersString(builderTypeElement)); } } } ImmutableSet builderMethods = methods.build(); if (builderMethods.size() > 1) { errorReporter.reportError( builderMethods.iterator().next(), "[AutoValueTwoBuilderConverters] There can be at most one builder converter method"); } this.toBuilderMethods = builderMethods; return builderMethods; } void defineVarsForAutoValue( AutoValueOrBuilderTemplateVars vars, ImmutableBiMap getterToPropertyName, Nullables nullables) { Iterable builderMethods = abstractMethods(builderTypeElement, processingEnv); boolean autoValueHasToBuilder = toBuilderMethods != null && !toBuilderMethods.isEmpty(); ImmutableMap getterToPropertyType = TypeVariables.rewriteReturnTypes( processingEnv.getElementUtils(), processingEnv.getTypeUtils(), getterToPropertyName.keySet(), autoValueClass, builderTypeElement); ImmutableMap.Builder rewrittenPropertyTypes = ImmutableMap.builder(); getterToPropertyType.forEach( (getter, type) -> rewrittenPropertyTypes.put(getterToPropertyName.get(getter), type)); Optional> optionalClassifier = BuilderMethodClassifierForAutoValue.classify( builderMethods, errorReporter, processingEnv, autoValueClass, builderTypeElement, getterToPropertyName, rewrittenPropertyTypes.build(), nullables, autoValueHasToBuilder); if (!optionalClassifier.isPresent()) { return; } for (ExecutableElement method : methodsIn(builderTypeElement.getEnclosedElements())) { if (method.getSimpleName().contentEquals("builder") && method.getModifiers().contains(Modifier.STATIC) && method.getAnnotationMirrors().isEmpty() && !(vars instanceof AutoBuilderTemplateVars)) { // For now we don't warn for methods with annotations, because for example we do want to // allow Jackson's @JsonCreator. We also don't warn if this is an @AutoBuilder. errorReporter.reportWarning( method, "[AutoValueBuilderInBuilder] Static builder() method should be in the containing" + " class"); } } defineVars(vars, optionalClassifier.get()); } void defineVars(AutoValueOrBuilderTemplateVars vars, BuilderMethodClassifier classifier) { this.classifier = classifier; Set buildMethods = classifier.buildMethods(); if (buildMethods.size() != 1) { Set errorElements = buildMethods.isEmpty() ? ImmutableSet.of(builderTypeElement) : buildMethods; for (Element buildMethod : errorElements) { errorReporter.reportError( buildMethod, "[AutoValueBuilderBuild] Builder must have a single no-argument method, typically" + " called build(), that returns %s%s", autoValueClass, typeParamsString()); } errorReporter.abortIfAnyError(); return; } this.buildMethod = Iterables.getOnlyElement(buildMethods); vars.builderIsInterface = builderTypeElement.getKind() == ElementKind.INTERFACE; vars.builderTypeName = TypeSimplifier.classNameOf(builderTypeElement); vars.builderFormalTypes = TypeEncoder.typeParametersString(builderTypeElement.getTypeParameters()); vars.builderActualTypes = TypeSimplifier.actualTypeParametersString(builderTypeElement); vars.buildMethod = Optional.of(new SimpleMethod(buildMethod)); vars.builderGetters = classifier.builderGetters(); vars.builderSetters = classifier.propertyNameToSetters(); vars.builderPropertyBuilders = ImmutableMap.copyOf(classifier.propertyNameToPropertyBuilder()); ImmutableSet requiredProperties = vars.props.stream() .filter(p -> !p.isNullable()) .filter(p -> p.getBuilderInitializer().isEmpty()) .filter(p -> !p.hasDefault()) .filter(p -> !vars.builderPropertyBuilders.containsKey(p.getName())) .collect(toImmutableSet()); vars.builderRequiredProperties = BuilderRequiredProperties.of(vars.props, requiredProperties); } } /** * Information about a builder property getter, referenced from the autovalue.vm template. A * property called foo (defined by a method {@code T foo()} or {@code T getFoo()}) can have a * getter method in the builder with the same name ({@code foo()} or {@code getFoo()}) and a * return type of either {@code T} or {@code Optional}. The {@code Optional} form can be * used to tell whether the property has been set. Here, {@code Optional} can be either {@code * java.util.Optional} or {@code com.google.common.base.Optional}. If {@code T} is {@code int}, * {@code long}, or {@code double}, then instead of {@code Optional} we can have {@code * OptionalInt} etc. If {@code T} is a primitive type (including these ones but also the other * five) then {@code Optional} can be the corresponding boxed type. */ public static class PropertyGetter { private final String name; private final String access; private final String type; private final Optionalish optional; /** * Makes a new {@code PropertyGetter} instance. * * @param method the source method which this getter is implementing. * @param type the type that the getter returns. This is written to take imports into account, * so it might be {@code List} for example. It is either identical to the type of * the corresponding getter in the {@code @AutoValue} class, or it is an optional wrapper, * like {@code Optional>}. * @param optional a representation of the {@code Optional} type that the getter returns, if * this is an optional getter, or null otherwise. An optional getter is one that returns * {@code Optional} rather than {@code T}, as explained above. */ PropertyGetter(ExecutableElement method, String type, Optionalish optional) { this.name = method.getSimpleName().toString(); this.access = SimpleMethod.access(method); this.type = type; this.optional = optional; } public String getName() { return name; } public String getAccess() { return access; } public String getType() { return type; } public Optionalish getOptional() { return optional; } } /** * Specifies how to copy a parameter value into the target type. This might be the identity, or it * might be something like {@code ImmutableList.of(...)} or {@code Optional.ofNullable(...)}. */ static class Copier { static final Copier IDENTITY = acceptingNull(x -> x); private final Function copy; private final boolean acceptsNull; private Copier(Function copy, boolean acceptsNull) { this.copy = copy; this.acceptsNull = acceptsNull; } static Copier acceptingNull(Function copy) { return new Copier(copy, true); } static Copier notAcceptingNull(Function copy) { return new Copier(copy, false); } } /** * Information about a property setter, referenced from the autovalue.vm template. A property * called foo (defined by a method {@code T foo()} or {@code T getFoo()}) can have a setter method * {@code foo(T)} or {@code setFoo(T)} that returns the builder type. Additionally, it can have a * setter with a type that can be copied to {@code T} through a {@code copyOf} method; for example * a property {@code foo} of type {@code ImmutableSet} can be set with a method {@code * setFoo(Collection foos)}. And, if {@code T} is {@code Optional}, it can have a setter * with a type that can be copied to {@code T} through {@code Optional.of}. */ public static class PropertySetter { private final ExecutableElement setter; private final String access; private final String name; private final String parameterTypeString; private final boolean primitiveParameter; private final String nullableAnnotation; private final Copier copier; PropertySetter(ExecutableElement setter, TypeMirror parameterType, Copier copier) { this.setter = setter; this.copier = copier; this.access = SimpleMethod.access(setter); this.name = setter.getSimpleName().toString(); primitiveParameter = parameterType.getKind().isPrimitive(); this.parameterTypeString = parameterTypeString(setter, parameterType); VariableElement parameterElement = Iterables.getOnlyElement(setter.getParameters()); Optional maybeNullable = nullableAnnotationFor(parameterElement, parameterType); this.nullableAnnotation = maybeNullable.orElse(""); } ExecutableElement getSetter() { return setter; } private static String parameterTypeString(ExecutableElement setter, TypeMirror parameterType) { if (setter.isVarArgs()) { TypeMirror componentType = MoreTypes.asArray(parameterType).getComponentType(); // This is a bit ugly. It's OK to annotate just the component type, because if it is // say `@Nullable String` then we will end up with `@Nullable String...`. Unlike the // normal array case, we can't have the situation where the array itself is annotated; // you can write `String @Nullable []` to mean that, but you can't write // `String @Nullable ...`. return TypeEncoder.encodeWithAnnotations(componentType) + "..."; } else { return TypeEncoder.encodeWithAnnotations(parameterType); } } public String getAccess() { return access; } public String getName() { return name; } public String getParameterType() { return parameterTypeString; } public boolean getPrimitiveParameter() { return primitiveParameter; } public String getNullableAnnotation() { return nullableAnnotation; } public String copy(Property property) { String copy = copier.copy.apply(property.toString()); if (property.isNullable() && !copier.acceptsNull) { copy = String.format("(%s == null ? null : %s)", property, copy); } return copy; } } /** * Returns a representation of the given {@code @AutoValue.Builder} class or interface. If the * class or interface has abstract methods that could not be part of any builder, emits error * messages and returns Optional.empty(). */ private Optional builderFrom(TypeElement builderTypeElement) { // We require the builder to have the same type parameters as the @AutoValue class, meaning the // same names and bounds. In principle the type parameters could have different names, but that // would be confusing, and our code would reject it anyway because it wouldn't consider that // the return type of Foo build() was really the same as the declaration of Foo. This // check produces a better error message in that case and similar ones. if (!sameTypeParameters(autoValueClass, builderTypeElement)) { errorReporter.reportError( builderTypeElement, "[AutoValueTypeParamMismatch] Type parameters of %s must have same names and bounds as" + " type parameters of %s", builderTypeElement, autoValueClass); return Optional.empty(); } return Optional.of(new Builder(builderTypeElement)); } private static boolean sameTypeParameters(TypeElement a, TypeElement b) { return sameTypeParameters(a.getTypeParameters(), b.getTypeParameters()); } static boolean sameTypeParameters( List aParams, List bParams) { int nTypeParameters = aParams.size(); if (nTypeParameters != bParams.size()) { return false; } for (int i = 0; i < nTypeParameters; i++) { TypeParameterElement aParam = aParams.get(i); TypeParameterElement bParam = bParams.get(i); if (!aParam.getSimpleName().equals(bParam.getSimpleName())) { return false; } Set aBounds = new TypeMirrorSet(aParam.getBounds()); Set bBounds = new TypeMirrorSet(bParam.getBounds()); if (!aBounds.equals(bBounds)) { return false; } } return true; } /** * Returns a set of all abstract methods in the given TypeElement or inherited from ancestors. If * any of the abstract methods has a return type or parameter type that is not currently defined * then this method will throw an exception that will cause us to defer processing of the current * class until a later annotation-processing round. */ static ImmutableSet abstractMethods( TypeElement typeElement, ProcessingEnvironment processingEnv) { Set methods = getLocalAndInheritedMethods( typeElement, processingEnv.getTypeUtils(), processingEnv.getElementUtils()); ImmutableSet.Builder abstractMethods = ImmutableSet.builder(); for (ExecutableElement method : methods) { if (method.getModifiers().contains(Modifier.ABSTRACT)) { MissingTypes.deferIfMissingTypesIn(method); abstractMethods.add(method); } } return abstractMethods.build(); } private String typeParamsString() { return TypeSimplifier.actualTypeParametersString(autoValueClass); } }