com.google.auto.value.extension.memoized.processor.MemoizeExtension Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of auto-value Show documentation
Show all versions of auto-value Show documentation
Immutable value-type code generation for Java 1.6+.
/*
* Copyright (C) 2016 Google, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.auto.value.extension.memoized.processor;
import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
import static com.google.auto.common.GeneratedAnnotationSpecs.generatedAnnotationSpec;
import static com.google.auto.common.MoreElements.getPackage;
import static com.google.auto.common.MoreElements.isAnnotationPresent;
import static com.google.auto.value.extension.memoized.processor.ClassNames.MEMOIZED_NAME;
import static com.google.auto.value.extension.memoized.processor.MemoizedValidator.getAnnotationMirror;
import static com.google.common.base.Predicates.equalTo;
import static com.google.common.base.Predicates.not;
import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.collect.ImmutableSet.toImmutableSet;
import static com.google.common.collect.Iterables.filter;
import static com.google.common.collect.Iterables.getOnlyElement;
import static com.google.common.collect.Sets.union;
import static com.squareup.javapoet.MethodSpec.constructorBuilder;
import static com.squareup.javapoet.MethodSpec.methodBuilder;
import static com.squareup.javapoet.TypeSpec.classBuilder;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
import static javax.lang.model.element.Modifier.ABSTRACT;
import static javax.lang.model.element.Modifier.FINAL;
import static javax.lang.model.element.Modifier.PRIVATE;
import static javax.lang.model.element.Modifier.PUBLIC;
import static javax.lang.model.element.Modifier.STATIC;
import static javax.lang.model.element.Modifier.TRANSIENT;
import static javax.lang.model.element.Modifier.VOLATILE;
import static javax.lang.model.type.TypeKind.VOID;
import static javax.lang.model.util.ElementFilter.methodsIn;
import static javax.tools.Diagnostic.Kind.ERROR;
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.auto.common.Visibility;
import com.google.auto.service.AutoService;
import com.google.auto.value.extension.AutoValueExtension;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.squareup.javapoet.AnnotationSpec;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.CodeBlock;
import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeName;
import com.squareup.javapoet.TypeSpec;
import com.squareup.javapoet.TypeVariableName;
import java.lang.annotation.Inherited;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.QualifiedNameable;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import javax.tools.Diagnostic.Kind;
/**
* An extension that implements the {@link com.google.auto.value.extension.memoized.Memoized}
* contract.
*/
@AutoService(AutoValueExtension.class)
public final class MemoizeExtension extends AutoValueExtension {
private static final ImmutableSet DO_NOT_PULL_DOWN_ANNOTATIONS =
ImmutableSet.of(Override.class.getCanonicalName(), MEMOIZED_NAME);
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private static final String AUTO_VALUE_PACKAGE_NAME = "com.google.auto.value.";
private static final String AUTO_VALUE_NAME = AUTO_VALUE_PACKAGE_NAME + "AutoValue";
private static final String COPY_ANNOTATIONS_NAME = AUTO_VALUE_NAME + ".CopyAnnotations";
private static final ClassName LAZY_INIT =
ClassName.get("com.google.errorprone.annotations.concurrent", "LazyInit");
private static final AnnotationSpec SUPPRESS_WARNINGS =
AnnotationSpec.builder(SuppressWarnings.class).addMember("value", "$S", "Immutable").build();
@Override
public IncrementalExtensionType incrementalType(ProcessingEnvironment processingEnvironment) {
return IncrementalExtensionType.ISOLATING;
}
@Override
public boolean applicable(Context context) {
return !memoizedMethods(context).isEmpty();
}
@Override
public String generateClass(
Context context, String className, String classToExtend, boolean isFinal) {
return new Generator(context, className, classToExtend, isFinal).generate();
}
private static ImmutableSet memoizedMethods(Context context) {
ImmutableSet.Builder memoizedMethods = ImmutableSet.builder();
for (ExecutableElement method : methodsIn(context.autoValueClass().getEnclosedElements())) {
if (getAnnotationMirror(method, MEMOIZED_NAME).isPresent()) {
memoizedMethods.add(method);
}
}
return memoizedMethods.build();
}
static final class Generator {
private final Context context;
private final String className;
private final String classToExtend;
private final boolean isFinal;
private final Elements elements;
private final Types types;
private final SourceVersion sourceVersion;
private final Messager messager;
private final Optional lazyInitAnnotation;
private boolean hasErrors;
Generator(Context context, String className, String classToExtend, boolean isFinal) {
this.context = context;
this.className = className;
this.classToExtend = classToExtend;
this.isFinal = isFinal;
this.elements = context.processingEnvironment().getElementUtils();
this.types = context.processingEnvironment().getTypeUtils();
this.sourceVersion = context.processingEnvironment().getSourceVersion();
this.messager = context.processingEnvironment().getMessager();
this.lazyInitAnnotation = getLazyInitAnnotation(elements);
}
String generate() {
TypeSpec.Builder generated =
classBuilder(className)
.superclass(superType())
.addAnnotations(copiedClassAnnotations(context.autoValueClass()))
.addTypeVariables(typeVariableNames())
.addModifiers(isFinal ? FINAL : ABSTRACT)
.addMethod(constructor());
generatedAnnotationSpec(elements, sourceVersion, MemoizeExtension.class)
.ifPresent(generated::addAnnotation);
for (ExecutableElement method : memoizedMethods(context)) {
MethodOverrider methodOverrider = new MethodOverrider(method);
generated.addFields(methodOverrider.fields());
generated.addMethod(methodOverrider.method());
}
if (isHashCodeMemoized() && !isEqualsFinal()) {
generated.addMethod(equalsWithHashCodeCheck());
}
if (hasErrors) {
return null;
}
return JavaFile.builder(context.packageName(), generated.build()).build().toString();
}
private TypeName superType() {
ClassName superType = ClassName.get(context.packageName(), classToExtend);
ImmutableList typeVariableNames = typeVariableNames();
return typeVariableNames.isEmpty()
? superType
: ParameterizedTypeName.get(superType, typeVariableNames.toArray(new TypeName[] {}));
}
private ImmutableList typeVariableNames() {
ImmutableList.Builder typeVariableNamesBuilder = ImmutableList.builder();
for (TypeParameterElement typeParameter : context.autoValueClass().getTypeParameters()) {
typeVariableNamesBuilder.add(TypeVariableName.get(typeParameter));
}
return typeVariableNamesBuilder.build();
}
private MethodSpec constructor() {
MethodSpec.Builder constructor = constructorBuilder();
for (Map.Entry property : context.properties().entrySet()) {
constructor.addParameter(annotatedReturnType(property.getValue()), property.getKey() + "$");
}
List namesWithDollars = new ArrayList();
for (String property : context.properties().keySet()) {
namesWithDollars.add(property + "$");
}
constructor.addStatement("super($L)", Joiner.on(", ").join(namesWithDollars));
return constructor.build();
}
private boolean isHashCodeMemoized() {
return memoizedMethods(context).stream()
.anyMatch(method -> method.getSimpleName().contentEquals("hashCode"));
}
private boolean isEqualsFinal() {
TypeMirror objectType = elements.getTypeElement(Object.class.getCanonicalName()).asType();
ExecutableElement equals =
MoreElements.getLocalAndInheritedMethods(context.autoValueClass(), types, elements)
.stream()
.filter(method -> method.getSimpleName().contentEquals("equals"))
.filter(method -> method.getParameters().size() == 1)
.filter(
method ->
types.isSameType(getOnlyElement(method.getParameters()).asType(), objectType))
.findFirst()
.get();
return equals.getModifiers().contains(FINAL);
}
private MethodSpec equalsWithHashCodeCheck() {
return methodBuilder("equals")
.addModifiers(PUBLIC)
.returns(TypeName.BOOLEAN)
.addAnnotation(Override.class)
.addParameter(TypeName.OBJECT, "that")
.beginControlFlow("if (this == that)")
.addStatement("return true")
.endControlFlow()
.addStatement(
"return that instanceof $N "
+ "&& this.hashCode() == that.hashCode() "
+ "&& super.equals(that)",
className)
.build();
}
/**
* True if the given class name is in the com.google.auto.value package or a subpackage. False
* if the class name contains {@code Test}, since many AutoValue tests under
* com.google.auto.value define their own annotations.
*/
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private boolean isInAutoValuePackage(String className) {
return className.startsWith(AUTO_VALUE_PACKAGE_NAME) && !className.contains("Test");
}
/**
* Returns the fully-qualified name of an annotation-mirror, e.g.
* "com.google.auto.value.AutoValue".
*/
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private static String getAnnotationFqName(AnnotationMirror annotation) {
return ((QualifiedNameable) annotation.getAnnotationType().asElement())
.getQualifiedName()
.toString();
}
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private boolean annotationVisibleFrom(AnnotationMirror annotation, Element from) {
Element annotationElement = annotation.getAnnotationType().asElement();
Visibility visibility = Visibility.effectiveVisibilityOfElement(annotationElement);
switch (visibility) {
case PUBLIC:
return true;
case PROTECTED:
// If the annotation is protected, it must be inside another class, call it C. If our
// @AutoValue class is Foo then, for the annotation to be visible, either Foo must be in
// the same package as C or Foo must be a subclass of C. If the annotation is visible from
// Foo then it is also visible from our generated subclass AutoValue_Foo.
// The protected case only applies to method annotations. An annotation on the
// AutoValue_Foo class itself can't be protected, even if AutoValue_Foo ultimately
// inherits from the class that defines the annotation. The JLS says "Access is permitted
// only within the body of a subclass":
// https://docs.oracle.com/javase/specs/jls/se8/html/jls-6.html#jls-6.6.2.1
// AutoValue_Foo is a top-level class, so an annotation on it cannot be in the body of a
// subclass of anything.
return getPackage(annotationElement).equals(getPackage(from))
|| types.isSubtype(from.asType(), annotationElement.getEnclosingElement().asType());
case DEFAULT:
return getPackage(annotationElement).equals(getPackage(from));
default:
return false;
}
}
/** Implements the semantics of {@code AutoValue.CopyAnnotations}; see its javadoc. */
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private ImmutableList annotationsToCopy(
Element autoValueType, Element typeOrMethod, Set excludedAnnotations) {
ImmutableList.Builder result = ImmutableList.builder();
for (AnnotationMirror annotation : typeOrMethod.getAnnotationMirrors()) {
String annotationFqName = getAnnotationFqName(annotation);
// To be included, the annotation should not be in com.google.auto.value,
// and it should not be in the excludedAnnotations set.
if (!isInAutoValuePackage(annotationFqName)
&& !excludedAnnotations.contains(annotationFqName)
&& annotationVisibleFrom(annotation, autoValueType)) {
result.add(annotation);
}
}
return result.build();
}
/** Implements the semantics of {@code AutoValue.CopyAnnotations}; see its javadoc. */
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private ImmutableList copyAnnotations(
Element autoValueType, Element typeOrMethod, Set excludedAnnotations) {
ImmutableList annotationsToCopy =
annotationsToCopy(autoValueType, typeOrMethod, excludedAnnotations);
return annotationsToCopy.stream().map(AnnotationSpec::get).collect(toImmutableList());
}
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private static boolean hasAnnotationMirror(Element element, String annotationName) {
return getAnnotationMirror(element, annotationName).isPresent();
}
/**
* Returns the contents of the {@code AutoValue.CopyAnnotations.exclude} element, as a set of
* {@code TypeMirror} where each type is an annotation type.
*/
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private ImmutableSet getExcludedAnnotationTypes(Element element) {
Optional maybeAnnotation =
getAnnotationMirror(element, COPY_ANNOTATIONS_NAME);
if (!maybeAnnotation.isPresent()) {
return ImmutableSet.of();
}
@SuppressWarnings("unchecked")
List excludedClasses =
(List) getAnnotationValue(maybeAnnotation.get(), "exclude").getValue();
return excludedClasses.stream()
.map(
annotationValue ->
MoreTypes.equivalence().wrap((TypeMirror) annotationValue.getValue()))
// TODO(b/122509249): Move TypeMirrorSet to common package instead of doing this.
.distinct()
.map(Wrapper::get)
.collect(toImmutableSet());
}
/**
* Returns the contents of the {@code AutoValue.CopyAnnotations.exclude} element, as a set of
* strings that are fully-qualified class names.
*/
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private Set getExcludedAnnotationClassNames(Element element) {
return getExcludedAnnotationTypes(element).stream()
.map(MoreTypes::asTypeElement)
.map(typeElement -> typeElement.getQualifiedName().toString())
.collect(toSet());
}
// TODO(b/122509249): Move code copied from com.google.auto.value.processor to auto-common.
private static Set getAnnotationsMarkedWithInherited(Element element) {
return element.getAnnotationMirrors().stream()
.filter(a -> isAnnotationPresent(a.getAnnotationType().asElement(), Inherited.class))
.map(Generator::getAnnotationFqName)
.collect(toSet());
}
private ImmutableList copiedClassAnnotations(TypeElement type) {
// Only copy annotations from a class if it has @AutoValue.CopyAnnotations.
if (hasAnnotationMirror(type, COPY_ANNOTATIONS_NAME)) {
Set excludedAnnotations =
union(getExcludedAnnotationClassNames(type), getAnnotationsMarkedWithInherited(type));
return copyAnnotations(type, type, excludedAnnotations);
} else {
return ImmutableList.of();
}
}
/**
* Determines the required fields and overriding method for a {@link
* com.google.auto.value.extension.memoized.Memoized @Memoized} method.
*/
private final class MethodOverrider {
private final ExecutableElement method;
private final MethodSpec.Builder override;
private final FieldSpec cacheField;
private final ImmutableList.Builder fields = ImmutableList.builder();
MethodOverrider(ExecutableElement method) {
this.method = method;
validate();
cacheField =
buildCacheField(annotatedReturnType(method), method.getSimpleName().toString());
fields.add(cacheField);
override =
methodBuilder(method.getSimpleName().toString())
.addAnnotation(Override.class)
.returns(cacheField.type)
.addExceptions(
method.getThrownTypes().stream().map(TypeName::get).collect(toList()))
.addModifiers(filter(method.getModifiers(), not(equalTo(ABSTRACT))));
for (AnnotationMirror annotation : method.getAnnotationMirrors()) {
AnnotationSpec annotationSpec = AnnotationSpec.get(annotation);
if (pullDownMethodAnnotation(annotation)) {
override.addAnnotation(annotationSpec);
}
}
InitializationStrategy checkStrategy = strategy();
fields.addAll(checkStrategy.additionalFields());
override
.beginControlFlow("if ($L)", checkStrategy.checkMemoized())
.beginControlFlow("synchronized (this)")
.beginControlFlow("if ($L)", checkStrategy.checkMemoized())
.addStatement("$N = super.$L()", cacheField, method.getSimpleName())
.addCode(checkStrategy.setMemoized())
.endControlFlow()
.endControlFlow()
.endControlFlow()
.addStatement("return $N", cacheField);
}
/** The fields that should be added to the subclass. */
Iterable fields() {
return fields.build();
}
/** The overriding method that should be added to the subclass. */
MethodSpec method() {
return override.build();
}
private void validate() {
if (method.getReturnType().getKind().equals(VOID)) {
printMessage(ERROR, "@Memoized methods cannot be void");
}
if (!method.getParameters().isEmpty()) {
printMessage(ERROR, "@Memoized methods cannot have parameters");
}
checkIllegalModifier(PRIVATE);
checkIllegalModifier(FINAL);
checkIllegalModifier(STATIC);
if (!overridesObjectMethod("hashCode") && !overridesObjectMethod("toString")) {
checkIllegalModifier(ABSTRACT);
}
}
private void checkIllegalModifier(Modifier modifier) {
if (method.getModifiers().contains(modifier)) {
printMessage(ERROR, "@Memoized methods cannot be " + modifier.toString());
}
}
private void printMessage(Kind kind, String format, Object... args) {
if (kind.equals(ERROR)) {
hasErrors = true;
}
messager.printMessage(kind, String.format(format, args), method);
}
private boolean overridesObjectMethod(String methodName) {
return elements.overrides(method, objectMethod(methodName), context.autoValueClass());
}
private ExecutableElement objectMethod(final String methodName) {
TypeElement object = elements.getTypeElement(Object.class.getName());
for (ExecutableElement method : methodsIn(object.getEnclosedElements())) {
if (method.getSimpleName().contentEquals(methodName)) {
return method;
}
}
throw new IllegalArgumentException(
String.format("No method in Object named \"%s\"", methodName));
}
private boolean pullDownMethodAnnotation(AnnotationMirror annotation) {
return !DO_NOT_PULL_DOWN_ANNOTATIONS.contains(
MoreElements.asType(annotation.getAnnotationType().asElement())
.getQualifiedName()
.toString());
}
/**
* Builds a {@link FieldSpec} for use in property caching. Field will be {@code private
* transient volatile} and have the given type and name. If the @LazyInit annotation is
* available it is added as well.
*/
private FieldSpec buildCacheField(TypeName type, String name) {
FieldSpec.Builder builder = FieldSpec.builder(type, name, PRIVATE, TRANSIENT, VOLATILE);
if (lazyInitAnnotation.isPresent()) {
builder.addAnnotation(lazyInitAnnotation.get());
builder.addAnnotation(SUPPRESS_WARNINGS);
}
return builder.build();
}
InitializationStrategy strategy() {
if (method.getReturnType().getKind().isPrimitive()) {
return new CheckBooleanField();
}
if (containsNullable(method.getAnnotationMirrors())
|| containsNullable(method.getReturnType().getAnnotationMirrors())) {
return new CheckBooleanField();
}
return new NullMeansUninitialized();
}
private abstract class InitializationStrategy {
abstract Iterable additionalFields();
abstract CodeBlock checkMemoized();
abstract CodeBlock setMemoized();
}
private final class NullMeansUninitialized extends InitializationStrategy {
@Override
Iterable additionalFields() {
return ImmutableList.of();
}
@Override
CodeBlock checkMemoized() {
return CodeBlock.of("$N == null", cacheField);
}
@Override
CodeBlock setMemoized() {
return CodeBlock.builder()
.beginControlFlow("if ($N == null)", cacheField)
.addStatement(
"throw new NullPointerException($S)",
method.getSimpleName() + "() cannot return null")
.endControlFlow()
.build();
}
}
private final class CheckBooleanField extends InitializationStrategy {
private final FieldSpec field =
buildCacheField(TypeName.BOOLEAN, method.getSimpleName() + "$Memoized");
@Override
Iterable additionalFields() {
return ImmutableList.of(field);
}
@Override
CodeBlock checkMemoized() {
return CodeBlock.of("!$N", field);
}
@Override
CodeBlock setMemoized() {
return CodeBlock.builder().addStatement("$N = true", field).build();
}
}
}
}
/** Returns the errorprone {@code @LazyInit} annotation if it is found on the classpath. */
private static Optional getLazyInitAnnotation(Elements elements) {
if (elements.getTypeElement(LAZY_INIT.toString()) == null) {
return Optional.empty();
}
return Optional.of(AnnotationSpec.builder(LAZY_INIT).build());
}
/** True if one of the given annotations is {@code @Nullable} in any package. */
private static boolean containsNullable(List annotations) {
return annotations.stream()
.map(a -> a.getAnnotationType().asElement().getSimpleName())
.anyMatch(n -> n.contentEquals("Nullable"));
}
/** The return type of the given method, including type annotations. */
private static TypeName annotatedReturnType(ExecutableElement method) {
TypeMirror returnType = method.getReturnType();
List annotations =
returnType.getAnnotationMirrors().stream()
.map(AnnotationSpec::get)
.collect(toList());
return TypeName.get(returnType).annotated(annotations);
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy