Merge changes from topic "google-java-format-jdk17" am: 6393823b21 am: 95df6f6cad am: 24a44d71c9
Original change: https://android-review.googlesource.com/c/platform/external/auto/+/2008542
Change-Id: I2f6c9fe46f8f56ad35781713a93ea1a5cc2504ab
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..18cc4ce
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,22 @@
+version: 2
+updates:
+ - package-ecosystem: "maven"
+ directory: "/common"
+ schedule:
+ interval: "daily"
+ - package-ecosystem: "maven"
+ directory: "/factory"
+ schedule:
+ interval: "daily"
+ - package-ecosystem: "maven"
+ directory: "/service"
+ schedule:
+ interval: "daily"
+ - package-ecosystem: "maven"
+ directory: "/value"
+ schedule:
+ interval: "daily"
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "daily"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..ec92243
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,97 @@
+name: CI
+
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+ branches:
+ - master
+
+jobs:
+ test:
+ name: "JDK ${{ matrix.java }}"
+ strategy:
+ matrix:
+ java: [ 8, 11 ]
+ runs-on: ubuntu-latest
+ steps:
+ # Cancel any previous runs for the same branch that are still running.
+ - name: 'Cancel previous runs'
+ uses: styfle/cancel-workflow-action@0.9.0
+ with:
+ access_token: ${{ github.token }}
+ - name: 'Check out repository'
+ uses: actions/checkout@v2.3.4
+ - name: 'Cache local Maven repository'
+ uses: actions/cache@v2.1.6
+ with:
+ path: ~/.m2/repository
+ key: maven-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ maven-
+ - name: 'Set up JDK ${{ matrix.java }}'
+ uses: actions/setup-java@v2
+ with:
+ java-version: ${{ matrix.java }}
+ distribution: 'zulu'
+ - name: 'Install'
+ shell: bash
+ run: mvn -B dependency:go-offline test clean -U --quiet --fail-never -DskipTests=true -f build-pom.xml
+ - name: 'Test'
+ shell: bash
+ run: mvn -B verify -U --fail-at-end -Dsource.skip=true -Dmaven.javadoc.skip=true -f build-pom.xml
+
+ publish_snapshot:
+ name: 'Publish snapshot'
+ needs: test
+ if: github.event_name == 'push' && github.repository == 'google/auto'
+ runs-on: ubuntu-latest
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2.3.4
+ - name: 'Cache local Maven repository'
+ uses: actions/cache@v2.1.6
+ with:
+ path: ~/.m2/repository
+ key: maven-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ maven-
+ - name: 'Set up JDK 11'
+ uses: actions/setup-java@v2
+ with:
+ java-version: 11
+ distribution: 'zulu'
+ server-id: sonatype-nexus-snapshots
+ server-username: CI_DEPLOY_USERNAME
+ server-password: CI_DEPLOY_PASSWORD
+ - name: 'Publish'
+ env:
+ CI_DEPLOY_USERNAME: ${{ secrets.CI_DEPLOY_USERNAME }}
+ CI_DEPLOY_PASSWORD: ${{ secrets.CI_DEPLOY_PASSWORD }}
+ run: ./util/publish-snapshot-on-commit.sh
+
+ generate_docs:
+ name: 'Generate latest docs'
+ needs: test
+ if: github.event_name == 'push' && github.repository == 'google/auto'
+ runs-on: ubuntu-latest
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2.3.4
+ - name: 'Cache local Maven repository'
+ uses: actions/cache@v2.1.6
+ with:
+ path: ~/.m2/repository
+ key: maven-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ maven-
+ - name: 'Set up JDK 11'
+ uses: actions/setup-java@v2
+ with:
+ java-version: 11
+ distribution: 'zulu'
+ - name: 'Generate latest docs'
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ run: ./util/generate-latest-docs.sh
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index b0be6fa..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-sudo: false
-
-language: java
-
-install:
- - mvn -B -U -f build-pom.xml dependency:go-offline test clean --quiet --fail-never -DskipTests=true
-
-script:
- - mvn -B -U -f build-pom.xml verify --fail-at-end -Dsource.skip=true -Dmaven.javadoc.skip=true
-
-jdk:
- - openjdk9
- - openjdk8
-
-env:
- global:
- - secure: "bWNSSMURwYC0oZWIMZRd7dy5+JdoyZ060d427TAqFRJmOkYtlR+dBbBggjeJmM0PEkQDzeBrWwln/Vq3lnRPv8czA7hSg/R33r3GzTyi1GZhjCYN2mPW8qp4qgqlloh78aaOODUNSJsOtQqPDJPmhLLfD6UCY0eq9zHhweIjYdw="
- - secure: "s5V9d8MKl7ZHqCxuYLljLSD4sp9KLtYkk9hVxEPqCLAi4zA70WkX9h+GZI1gAOpcavomfrWcgSDT2ZReiuNpwx7OtczdS4zB+s6mo4F598iRs4bhSLiPT+Hzvx6BSwf1ZKZTYEhrUPGmKOp2T29AxMV7D0Q+P7n574ubvpUuZmA="
- - secure: "T24JAd60zthkeLBmenvZn6+qI43uvfuLwVb70Ljhbc19XDYEZV4Zm/kaafsisP5+F6kV4GjFaT+NCq2sJlwvPSMMRvU1JJgmNVh8TmtswkC/PHKonkMkOsj2KmFP0RRSPdvQv2NrSguZUq8mg+2pvnPO0qoPg4VeIODPGtAxNb8="
-
-after_success:
- - util/generate-latest-docs.sh
- - util/publish-snapshot-on-commit.sh
-
-branches:
- only:
- - master
- - /^release.*$/
diff --git a/README.md b/README.md
index 366f940..bbefd27 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
# Auto
-[](https://travis-ci.org/google/auto)
+[](https://github.com/google/auto/actions/workflows/ci.yml)
A collection of source code generators for [Java][java].
diff --git a/android-annotation-stubs/gen_annotations.sh b/android-annotation-stubs/gen_annotations.sh
index 90c9fcf..4766af9 100755
--- a/android-annotation-stubs/gen_annotations.sh
+++ b/android-annotation-stubs/gen_annotations.sh
@@ -6,6 +6,7 @@
ANNOTATIONS=(
net.ltgt.gradle.incap.IncrementalAnnotationProcessor
+ org.checkerframework.checker.nullness.qual.Nullable
)
PARAMETER["net.ltgt.gradle.incap.IncrementalAnnotationProcessor"]="IncrementalAnnotationProcessorType"
diff --git a/android-annotation-stubs/src/org/checkerframework/checker/nullness/qual/Nullable.java b/android-annotation-stubs/src/org/checkerframework/checker/nullness/qual/Nullable.java
new file mode 100644
index 0000000..276d64c
--- /dev/null
+++ b/android-annotation-stubs/src/org/checkerframework/checker/nullness/qual/Nullable.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * 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 org.checkerframework.checker.nullness.qual;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/* This is an annotation stub to avoid dependencies on annotations that aren't
+ * in the Android platform source tree. */
+
+@Target({
+ ElementType.ANNOTATION_TYPE,
+ ElementType.CONSTRUCTOR,
+ ElementType.FIELD,
+ ElementType.LOCAL_VARIABLE,
+ ElementType.METHOD,
+ ElementType.PACKAGE,
+ ElementType.PARAMETER,
+ ElementType.TYPE,
+ ElementType.TYPE_PARAMETER,
+ ElementType.TYPE_USE
+})
+@Retention(RetentionPolicy.SOURCE)
+public @interface Nullable {}
diff --git a/common/Android.bp b/common/Android.bp
index 25f7099..19e2acd 100644
--- a/common/Android.bp
+++ b/common/Android.bp
@@ -11,6 +11,7 @@
name: "auto_common",
srcs: ["src/main/java/**/*.java"],
libs: [
+ "auto_android_annotation_stubs",
"guava",
"javapoet",
],
diff --git a/common/README.md b/common/README.md
index 990aa31..9f8eb79 100644
--- a/common/README.md
+++ b/common/README.md
@@ -1,28 +1,30 @@
-Auto Common Utilities
-========
+# Auto Common Utilities
## Overview
-The Auto project has a set of common utilities to help ease use of the annotation processing
-environment.
+The Auto project has a set of common utilities to help ease use of the
+annotation processing environment.
## Utility classes of note
- * MoreTypes - utilities and Equivalence wrappers for TypeMirror and related subtypes
- * MoreElements - utilities for Element and related subtypes
- * SuperficialValidation - very simple scanner to ensure an Element is valid and free from
- distortion from upstream compilation errors
- * Visibility - utilities for working with Elements' visibility levels (public, protected, etc.)
- * BasicAnnotationProcessor/ProcessingStep - simple types that
- - implement a validating annotation processor
- - defer invalid elements until later
- - break processor actions into multiple steps (which may each handle different annotations)
+* MoreTypes - utilities and Equivalence wrappers for TypeMirror and related
+ subtypes
+* MoreElements - utilities for Element and related subtypes
+* SuperficialValidation - very simple scanner to ensure an Element is valid
+ and free from distortion from upstream compilation errors
+* Visibility - utilities for working with Elements' visibility levels (public,
+ protected, etc.)
+* BasicAnnotationProcessor/ProcessingStep - simple types that
+ - implement a validating annotation processor
+ - defer invalid elements until later
+ - break processor actions into multiple steps (which may each handle
+ different annotations)
## Usage/Setup
-Auto common utilities have a standard [Maven](http://maven.apache.org) setup which can also be
-used from Gradle, Ivy, Ant, or other systems which consume binary artifacts from the central Maven
-binary artifact repositories.
+Auto common utilities have a standard [Maven](http://maven.apache.org) setup
+which can also be used from Gradle, Ivy, Ant, or other systems which consume
+binary artifacts from the central Maven binary artifact repositories.
```xml
<dependency>
@@ -31,49 +33,3 @@
<version>1.0-SNAPSHOT</version> <!-- or use a known release version -->
</dependency>
```
-
-## Processor Resilience
-
-Auto Common Utilities is used by a variety of annotation processors in Google and new versions
-may have breaking changes. Users of auto-common are urged to use
-[shade](https://maven.apache.org/plugins/maven-shade-plugin/) or
-[jarjar](https://code.google.com/p/jarjar/) (or something similar) in packaging their processors
-so that conflicting versions of this library do not adversely interact with each other.
-
-For example, in a Maven build you can repackage `com.google.auto.common` into
-`your.processor.shaded.auto.common` like this:
-
-```xml
-<project>
- <!-- your other config -->
- <build>
- <plugins>
- <plugin>
- <artifactId>maven-shade-plugin</artifactId>
- <executions>
- <execution>
- <phase>package</phase>
- <goals>
- <goal>shade</goal>
- </goals>
- <configuration>
- <artifactSet>
- <excludes>
- <!-- exclude dependencies you don't want to bundle in your processor -->
- </excludes>
- </artifactSet>
- <relocations>
- <relocation>
- <pattern>com.google.auto.common</pattern>
- <shadedPattern>your.processor.shaded.auto.common</shadedPattern>
- </relocation>
- </relocations>
- </configuration>
- </execution>
- </executions>
- </plugin>
- </plugins>
- </build>
-</project>
-```
-
diff --git a/common/pom.xml b/common/pom.xml
index e4a23e0..2754b81 100644
--- a/common/pom.xml
+++ b/common/pom.xml
@@ -36,8 +36,8 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
- <guava.version>29.0-jre</guava.version>
- <truth.version>1.0.1</truth.version>
+ <guava.version>30.1.1-jre</guava.version>
+ <truth.version>1.1.3</truth.version>
</properties>
<scm>
@@ -89,13 +89,13 @@
<dependency>
<groupId>com.google.testing.compile</groupId>
<artifactId>compile-testing</artifactId>
- <version>0.18</version>
+ <version>0.19</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
- <version>4.12</version>
+ <version>4.13.2</version>
<scope>test</scope>
</dependency>
<dependency>
@@ -107,7 +107,7 @@
<dependency>
<groupId>org.eclipse.jdt</groupId>
<artifactId>ecj</artifactId>
- <version>3.22.0</version>
+ <version>3.25.0</version>
<scope>test</scope>
</dependency>
</dependencies>
@@ -116,7 +116,7 @@
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
@@ -128,14 +128,14 @@
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
</plugin>
</plugins>
</build>
diff --git a/common/src/main/java/com/google/auto/common/AnnotationMirrors.java b/common/src/main/java/com/google/auto/common/AnnotationMirrors.java
index 62e5834..9ce5cd9 100644
--- a/common/src/main/java/com/google/auto/common/AnnotationMirrors.java
+++ b/common/src/main/java/com/google/auto/common/AnnotationMirrors.java
@@ -16,21 +16,21 @@
package com.google.auto.common;
import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Collections.unmodifiableMap;
import com.google.common.base.Equivalence;
-import com.google.common.base.Predicate;
-import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.lang.annotation.Annotation;
import java.util.Arrays;
-import java.util.List;
import java.util.Map;
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.TypeElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;
@@ -45,20 +45,32 @@
new Equivalence<AnnotationMirror>() {
@Override
protected boolean doEquivalent(AnnotationMirror left, AnnotationMirror right) {
- return MoreTypes.equivalence().equivalent(left.getAnnotationType(),
- right.getAnnotationType()) && AnnotationValues.equivalence().pairwise().equivalent(
- getAnnotationValuesWithDefaults(left).values(),
- getAnnotationValuesWithDefaults(right).values());
+ return MoreTypes.equivalence()
+ .equivalent(left.getAnnotationType(), right.getAnnotationType())
+ && AnnotationValues.equivalence()
+ .pairwise()
+ .equivalent(
+ getAnnotationValuesWithDefaults(left).values(),
+ getAnnotationValuesWithDefaults(right).values());
}
+
@Override
protected int doHash(AnnotationMirror annotation) {
DeclaredType type = annotation.getAnnotationType();
Iterable<AnnotationValue> annotationValues =
getAnnotationValuesWithDefaults(annotation).values();
- return Arrays.hashCode(new int[] {MoreTypes.equivalence().hash(type),
- AnnotationValues.equivalence().pairwise().hash(annotationValues)});
+ return Arrays.hashCode(
+ new int[] {
+ MoreTypes.equivalence().hash(type),
+ AnnotationValues.equivalence().pairwise().hash(annotationValues)
+ });
}
- };
+
+ @Override
+ public String toString() {
+ return "AnnotationMirrors.equivalence()";
+ }
+ };
/**
* Returns an {@link Equivalence} for {@link AnnotationMirror} as some implementations
@@ -83,8 +95,10 @@
public static ImmutableMap<ExecutableElement, AnnotationValue> getAnnotationValuesWithDefaults(
AnnotationMirror annotation) {
ImmutableMap.Builder<ExecutableElement, AnnotationValue> values = ImmutableMap.builder();
- Map<? extends ExecutableElement, ? extends AnnotationValue> declaredValues =
- annotation.getElementValues();
+ // Use unmodifiableMap to eliminate wildcards, which cause issues for our nullness checker.
+ @SuppressWarnings("GetElementValues")
+ Map<ExecutableElement, AnnotationValue> declaredValues =
+ unmodifiableMap(annotation.getElementValues());
for (ExecutableElement method :
ElementFilter.methodsIn(annotation.getAnnotationType().asElement().getEnclosedElements())) {
// Must iterate and put in this order, to ensure consistency in generated code.
@@ -95,8 +109,10 @@
} else {
throw new IllegalStateException(
"Unset annotation value without default should never happen: "
- + MoreElements.asType(method.getEnclosingElement()).getQualifiedName()
- + '.' + method.getSimpleName() + "()");
+ + MoreElements.asType(method.getEnclosingElement()).getQualifiedName()
+ + '.'
+ + method.getSimpleName()
+ + "()");
}
}
return values.build();
@@ -131,25 +147,48 @@
return entry;
}
}
- throw new IllegalArgumentException(String.format("@%s does not define an element %s()",
- MoreElements.asType(annotationMirror.getAnnotationType().asElement()).getQualifiedName(),
- elementName));
+ throw new IllegalArgumentException(
+ String.format(
+ "@%s does not define an element %s()",
+ MoreElements.asType(annotationMirror.getAnnotationType().asElement())
+ .getQualifiedName(),
+ elementName));
}
/**
- * Returns all {@linkplain AnnotationMirror annotations} that are present on the given
- * {@link Element} which are themselves annotated with {@code annotationType}.
+ * Returns all {@linkplain AnnotationMirror annotations} that are present on the given {@link
+ * Element} which are themselves annotated with {@code annotationClass}.
*/
- public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(Element element,
- final Class<? extends Annotation> annotationType) {
- List<? extends AnnotationMirror> annotations = element.getAnnotationMirrors();
- return FluentIterable.from(annotations)
- .filter(new Predicate<AnnotationMirror>() {
- @Override public boolean apply(AnnotationMirror input) {
- return isAnnotationPresent(input.getAnnotationType().asElement(), annotationType);
- }
- })
- .toSet();
+ public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(
+ Element element, Class<? extends Annotation> annotationClass) {
+ String name = annotationClass.getCanonicalName();
+ if (name == null) {
+ return ImmutableSet.of();
+ }
+ return getAnnotatedAnnotations(element, name);
+ }
+
+ /**
+ * Returns all {@linkplain AnnotationMirror annotations} that are present on the given {@link
+ * Element} which are themselves annotated with {@code annotation}.
+ */
+ public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(
+ Element element, TypeElement annotation) {
+ return element.getAnnotationMirrors().stream()
+ .filter(input -> isAnnotationPresent(input.getAnnotationType().asElement(), annotation))
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Returns all {@linkplain AnnotationMirror annotations} that are present on the given {@link
+ * Element} which are themselves annotated with an annotation whose type's canonical name is
+ * {@code annotationName}.
+ */
+ public static ImmutableSet<? extends AnnotationMirror> getAnnotatedAnnotations(
+ Element element, String annotationName) {
+ return element.getAnnotationMirrors().stream()
+ .filter(input -> isAnnotationPresent(input.getAnnotationType().asElement(), annotationName))
+ .collect(toImmutableSet());
}
private AnnotationMirrors() {}
diff --git a/common/src/main/java/com/google/auto/common/AnnotationValues.java b/common/src/main/java/com/google/auto/common/AnnotationValues.java
index e233901..0712e56 100644
--- a/common/src/main/java/com/google/auto/common/AnnotationValues.java
+++ b/common/src/main/java/com/google/auto/common/AnnotationValues.java
@@ -15,8 +15,8 @@
*/
package com.google.auto.common;
+import static com.google.auto.common.MoreStreams.toImmutableList;
import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.ImmutableList.toImmutableList;
import com.google.common.base.Equivalence;
import com.google.common.collect.ImmutableList;
@@ -37,91 +37,120 @@
public final class AnnotationValues {
private static final Equivalence<AnnotationValue> ANNOTATION_VALUE_EQUIVALENCE =
new Equivalence<AnnotationValue>() {
- @Override protected boolean doEquivalent(AnnotationValue left, AnnotationValue right) {
- return left.accept(new SimpleAnnotationValueVisitor8<Boolean, AnnotationValue>() {
- // LHS is not an annotation or array of annotation values, so just test equality.
- @Override protected Boolean defaultAction(Object left, AnnotationValue right) {
- return left.equals(right.accept(
- new SimpleAnnotationValueVisitor8<Object, Void>() {
- @Override protected Object defaultAction(Object object, Void unused) {
- return object;
- }
- }, null));
- }
+ @Override
+ protected boolean doEquivalent(AnnotationValue left, AnnotationValue right) {
+ return left.accept(
+ new SimpleAnnotationValueVisitor8<Boolean, AnnotationValue>() {
+ // LHS is not an annotation or array of annotation values, so just test equality.
+ @Override
+ protected Boolean defaultAction(Object left, AnnotationValue right) {
+ return left.equals(
+ right.accept(
+ new SimpleAnnotationValueVisitor8<Object, Void>() {
+ @Override
+ protected Object defaultAction(Object object, Void unused) {
+ return object;
+ }
+ },
+ null));
+ }
- // LHS is an annotation mirror so test equivalence for RHS annotation mirrors
- // and false for other types.
- @Override public Boolean visitAnnotation(AnnotationMirror left, AnnotationValue right) {
- return right.accept(
- new SimpleAnnotationValueVisitor8<Boolean, AnnotationMirror>() {
- @Override protected Boolean defaultAction(Object right, AnnotationMirror left) {
- return false; // Not an annotation mirror, so can't be equal to such.
- }
- @Override
- public Boolean visitAnnotation(AnnotationMirror right, AnnotationMirror left) {
- return AnnotationMirrors.equivalence().equivalent(left, right);
- }
- }, left);
- }
+ // LHS is an annotation mirror so test equivalence for RHS annotation mirrors
+ // and false for other types.
+ @Override
+ public Boolean visitAnnotation(AnnotationMirror left, AnnotationValue right) {
+ return right.accept(
+ new SimpleAnnotationValueVisitor8<Boolean, AnnotationMirror>() {
+ @Override
+ protected Boolean defaultAction(Object right, AnnotationMirror left) {
+ return false; // Not an annotation mirror, so can't be equal to such.
+ }
- // LHS is a list of annotation values have to collect-test equivalences, or false
- // for any other types.
- @Override
- public Boolean visitArray(List<? extends AnnotationValue> left, AnnotationValue right) {
- return right.accept(
- new SimpleAnnotationValueVisitor8<Boolean, List<? extends AnnotationValue>>() {
- @Override protected Boolean defaultAction(
- Object ignored, List<? extends AnnotationValue> alsoIgnored) {
- return false; // Not an array, so can't be equal to such.
- }
+ @Override
+ public Boolean visitAnnotation(
+ AnnotationMirror right, AnnotationMirror left) {
+ return AnnotationMirrors.equivalence().equivalent(left, right);
+ }
+ },
+ left);
+ }
- @SuppressWarnings("unchecked") // safe covariant cast
- @Override public Boolean visitArray(
- List<? extends AnnotationValue> right ,
- List<? extends AnnotationValue> left) {
- return AnnotationValues.equivalence().pairwise().equivalent(
- (List<AnnotationValue>) left, (List<AnnotationValue>) right);
- }
- }, left);
- }
+ // LHS is a list of annotation values have to collect-test equivalences, or false
+ // for any other types.
+ @Override
+ public Boolean visitArray(
+ List<? extends AnnotationValue> left, AnnotationValue right) {
+ return right.accept(
+ new SimpleAnnotationValueVisitor8<
+ Boolean, List<? extends AnnotationValue>>() {
+ @Override
+ protected Boolean defaultAction(
+ Object ignored, List<? extends AnnotationValue> alsoIgnored) {
+ return false; // Not an array, so can't be equal to such.
+ }
- @Override
- public Boolean visitType(TypeMirror left, AnnotationValue right) {
- return right.accept(
- new SimpleAnnotationValueVisitor8<Boolean, TypeMirror>() {
- @Override protected Boolean defaultAction(
- Object ignored, TypeMirror alsoIgnored) {
- return false; // Not an annotation mirror, so can't be equal to such.
- }
+ @SuppressWarnings("unchecked") // safe covariant cast
+ @Override
+ public Boolean visitArray(
+ List<? extends AnnotationValue> right,
+ List<? extends AnnotationValue> left) {
+ return AnnotationValues.equivalence()
+ .pairwise()
+ .equivalent(
+ (List<AnnotationValue>) left, (List<AnnotationValue>) right);
+ }
+ },
+ left);
+ }
- @Override public Boolean visitType(TypeMirror right, TypeMirror left) {
- return MoreTypes.equivalence().equivalent(left, right);
- }
- }, left);
- }
- }, right);
+ @Override
+ public Boolean visitType(TypeMirror left, AnnotationValue right) {
+ return right.accept(
+ new SimpleAnnotationValueVisitor8<Boolean, TypeMirror>() {
+ @Override
+ protected Boolean defaultAction(Object ignored, TypeMirror alsoIgnored) {
+ return false; // Not an annotation mirror, so can't be equal to such.
+ }
+
+ @Override
+ public Boolean visitType(TypeMirror right, TypeMirror left) {
+ return MoreTypes.equivalence().equivalent(left, right);
+ }
+ },
+ left);
+ }
+ },
+ right);
}
- @Override protected int doHash(AnnotationValue value) {
- return value.accept(new SimpleAnnotationValueVisitor8<Integer, Void>() {
- @Override public Integer visitAnnotation(AnnotationMirror value, Void ignore) {
- return AnnotationMirrors.equivalence().hash(value);
- }
+ @Override
+ protected int doHash(AnnotationValue value) {
+ return value.accept(
+ new SimpleAnnotationValueVisitor8<Integer, Void>() {
+ @Override
+ public Integer visitAnnotation(AnnotationMirror value, Void ignore) {
+ return AnnotationMirrors.equivalence().hash(value);
+ }
- @SuppressWarnings("unchecked") // safe covariant cast
- @Override public Integer visitArray(
- List<? extends AnnotationValue> values, Void ignore) {
- return AnnotationValues.equivalence().pairwise().hash((List<AnnotationValue>) values);
- }
+ @SuppressWarnings("unchecked") // safe covariant cast
+ @Override
+ public Integer visitArray(List<? extends AnnotationValue> values, Void ignore) {
+ return AnnotationValues.equivalence()
+ .pairwise()
+ .hash((List<AnnotationValue>) values);
+ }
- @Override public Integer visitType(TypeMirror value, Void ignore) {
- return MoreTypes.equivalence().hash(value);
- }
+ @Override
+ public Integer visitType(TypeMirror value, Void ignore) {
+ return MoreTypes.equivalence().hash(value);
+ }
- @Override protected Integer defaultAction(Object value, Void ignored) {
- return value.hashCode();
- }
- }, null);
+ @Override
+ protected Integer defaultAction(Object value, Void ignored) {
+ return value.hashCode();
+ }
+ },
+ null);
}
};
@@ -209,7 +238,6 @@
return value;
}
}
- ;
/**
* Returns the value as a VariableElement.
@@ -486,4 +514,3 @@
private AnnotationValues() {}
}
-
diff --git a/common/src/main/java/com/google/auto/common/BasicAnnotationProcessor.java b/common/src/main/java/com/google/auto/common/BasicAnnotationProcessor.java
index 375a4cb..d951aaf 100644
--- a/common/src/main/java/com/google/auto/common/BasicAnnotationProcessor.java
+++ b/common/src/main/java/com/google/auto/common/BasicAnnotationProcessor.java
@@ -17,14 +17,14 @@
import static com.google.auto.common.MoreElements.asExecutable;
import static com.google.auto.common.MoreElements.asPackage;
+import static com.google.auto.common.MoreStreams.toImmutableMap;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
import static com.google.auto.common.SuperficialValidation.validateElement;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.collect.Iterables.transform;
import static com.google.common.collect.Multimaps.filterKeys;
-import static java.util.stream.Collectors.collectingAndThen;
-import static java.util.stream.Collectors.toList;
-import static java.util.stream.Collectors.toMap;
+import static java.util.Objects.requireNonNull;
import static javax.lang.model.element.ElementKind.PACKAGE;
import static javax.tools.Diagnostic.Kind.ERROR;
@@ -56,6 +56,7 @@
import javax.lang.model.type.ErrorType;
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleElementVisitor8;
+import org.checkerframework.checker.nullness.qual.Nullable;
/**
* An abstract {@link Processor} implementation that defers processing of {@link Element}s to later
@@ -162,14 +163,14 @@
checkState(steps != null);
return steps.stream()
.flatMap(step -> getSupportedAnnotationTypeElements(step).stream())
- .collect(collectingAndThen(toList(), ImmutableSet::copyOf));
+ .collect(toImmutableSet());
}
private ImmutableSet<TypeElement> getSupportedAnnotationTypeElements(Step step) {
return step.annotations().stream()
.map(elements::getTypeElement)
.filter(Objects::nonNull)
- .collect(collectingAndThen(toList(), ImmutableSet::copyOf));
+ .collect(toImmutableSet());
}
/**
@@ -181,7 +182,7 @@
checkState(steps != null);
return steps.stream()
.flatMap(step -> step.annotations().stream())
- .collect(collectingAndThen(toList(), ImmutableSet::copyOf));
+ .collect(toImmutableSet());
}
@Override
@@ -287,10 +288,7 @@
// Look at the elements we've found and the new elements from this round and validate them.
for (TypeElement annotationType : getSupportedAnnotationTypeElements()) {
- Set<? extends Element> roundElements =
- (annotationType == null)
- ? ImmutableSet.of()
- : roundEnv.getElementsAnnotatedWith(annotationType);
+ Set<? extends Element> roundElements = roundEnv.getElementsAnnotatedWith(annotationType);
ImmutableSet<Element> prevRoundElements = deferredElementsByAnnotation.get(annotationType);
for (Element element : Sets.union(roundElements, prevRoundElements)) {
ElementName elementName = ElementName.forAnnotatedElement(element);
@@ -376,7 +374,7 @@
* IllegalArgumentException} if the provided {@link Element} is a {@link PackageElement} or is
* otherwise not enclosed by a type.
*/
- // TODO(cgruber) move to MoreElements and make public.
+ // TODO(user) move to MoreElements and make public.
private static TypeElement getEnclosingType(Element element) {
return element.accept(
new SimpleElementVisitor8<TypeElement, Void>() {
@@ -478,10 +476,9 @@
this.annotationsByName =
processingStep.annotations().stream()
.collect(
- collectingAndThen(
- toMap(
- Class::getCanonicalName, (Class<? extends Annotation> aClass) -> aClass),
- ImmutableMap::copyOf));
+ toImmutableMap(
+ c -> requireNonNull(c.getCanonicalName()),
+ (Class<? extends Annotation> aClass) -> aClass));
}
@Override
@@ -502,8 +499,12 @@
elements
.asMap()
.forEach(
- (annotation, annotatedElements) ->
- builder.putAll(annotationsByName.get(annotation), annotatedElements));
+ (annotationName, annotatedElements) -> {
+ Class<? extends Annotation> annotation = annotationsByName.get(annotationName);
+ if (annotation != null) { // should not be null
+ builder.putAll(annotation, annotatedElements);
+ }
+ });
return builder.build();
}
}
@@ -561,7 +562,7 @@
}
@Override
- public boolean equals(Object object) {
+ public boolean equals(@Nullable Object object) {
if (!(object instanceof ElementName)) {
return false;
}
diff --git a/common/src/main/java/com/google/auto/common/GeneratedAnnotationSpecs.java b/common/src/main/java/com/google/auto/common/GeneratedAnnotationSpecs.java
index bb35e22..09d9029 100644
--- a/common/src/main/java/com/google/auto/common/GeneratedAnnotationSpecs.java
+++ b/common/src/main/java/com/google/auto/common/GeneratedAnnotationSpecs.java
@@ -27,7 +27,7 @@
private GeneratedAnnotationSpecs() {}
/**
- * Returns {@code @Generated("processorClass"} if either {@code
+ * Returns {@code @Generated("processorClass")} if either {@code
* javax.annotation.processing.Generated} or {@code javax.annotation.Generated} is {@linkplain
* GeneratedAnnotations#generatedAnnotation(Elements) available at compile time}.
*
@@ -41,7 +41,7 @@
}
/**
- * Returns {@code @Generated(value = "processorClass", comments = "comments"} if either {@code
+ * Returns {@code @Generated(value = "processorClass", comments = "comments")} if either {@code
* javax.annotation.processing.Generated} or {@code javax.annotation.Generated} is {@linkplain
* GeneratedAnnotations#generatedAnnotation(Elements) available at compile time}.
*
@@ -55,7 +55,7 @@
}
/**
- * Returns {@code @Generated("processorClass"} for the target {@code SourceVersion}.
+ * Returns {@code @Generated("processorClass")} for the target {@code SourceVersion}.
*
* <p>Returns {@code javax.annotation.processing.Generated} for JDK 9 and newer, {@code
* javax.annotation.Generated} for earlier releases, and Optional#empty()} if the annotation is
@@ -68,7 +68,7 @@
}
/**
- * Returns {@code @Generated(value = "processorClass", comments = "comments"} for the target
+ * Returns {@code @Generated(value = "processorClass", comments = "comments")} for the target
* {@code SourceVersion}.
*
* <p>Returns {@code javax.annotation.processing.Generated} for JDK 9 and newer, {@code
diff --git a/common/src/main/java/com/google/auto/common/MoreElements.java b/common/src/main/java/com/google/auto/common/MoreElements.java
index 5e8e354..dfbbaee 100644
--- a/common/src/main/java/com/google/auto/common/MoreElements.java
+++ b/common/src/main/java/com/google/auto/common/MoreElements.java
@@ -16,6 +16,7 @@
*/
package com.google.auto.common;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
import static javax.lang.model.element.ElementKind.PACKAGE;
import static javax.lang.model.element.Modifier.STATIC;
@@ -212,29 +213,80 @@
}
/**
- * Returns {@code true} iff the given element has an {@link AnnotationMirror} whose
- * {@linkplain AnnotationMirror#getAnnotationType() annotation type} has the same canonical name
- * as that of {@code annotationClass}. This method is a safer alternative to calling
- * {@link Element#getAnnotation} and checking for {@code null} as it avoids any interaction with
+ * Returns {@code true} iff the given element has an {@link AnnotationMirror} whose {@linkplain
+ * AnnotationMirror#getAnnotationType() annotation type} has the same canonical name as that of
+ * {@code annotationClass}. This method is a safer alternative to calling {@link
+ * Element#getAnnotation} and checking for {@code null} as it avoids any interaction with
* annotation proxies.
*/
- public static boolean isAnnotationPresent(Element element,
- Class<? extends Annotation> annotationClass) {
+ public static boolean isAnnotationPresent(
+ Element element, Class<? extends Annotation> annotationClass) {
return getAnnotationMirror(element, annotationClass).isPresent();
}
/**
+ * Returns {@code true} iff the given element has an {@link AnnotationMirror} whose {@linkplain
+ * AnnotationMirror#getAnnotationType() annotation type} has the same fully qualified name as that
+ * of {@code annotation}. This method is a safer alternative to calling {@link
+ * Element#getAnnotation} and checking for {@code null} as it avoids any interaction with
+ * annotation proxies.
+ */
+ public static boolean isAnnotationPresent(Element element, TypeElement annotation) {
+ return getAnnotationMirror(element, annotation).isPresent();
+ }
+
+ /**
+ * Returns {@code true} iff the given element has an {@link AnnotationMirror} whose {@linkplain
+ * AnnotationMirror#getAnnotationType() annotation type} has {@code annotationName} as its
+ * canonical name. This method is a safer alternative to calling {@link Element#getAnnotation} and
+ * checking for {@code null} as it avoids any interaction with annotation proxies.
+ */
+ public static boolean isAnnotationPresent(Element element, String annotationName) {
+ return getAnnotationMirror(element, annotationName).isPresent();
+ }
+
+ /**
* Returns an {@link AnnotationMirror} for the annotation of type {@code annotationClass} on
* {@code element}, or {@link Optional#absent()} if no such annotation exists. This method is a
* safer alternative to calling {@link Element#getAnnotation} as it avoids any interaction with
* annotation proxies.
*/
- public static Optional<AnnotationMirror> getAnnotationMirror(Element element,
- Class<? extends Annotation> annotationClass) {
- String annotationClassName = annotationClass.getCanonicalName();
+ public static Optional<AnnotationMirror> getAnnotationMirror(
+ Element element, Class<? extends Annotation> annotationClass) {
+ String name = annotationClass.getCanonicalName();
+ if (name == null) {
+ return Optional.absent();
+ }
+ return getAnnotationMirror(element, name);
+ }
+
+ /**
+ * Returns an {@link AnnotationMirror} for the annotation of type {@code annotation} on {@code
+ * element}, or {@link Optional#absent()} if no such annotation exists. This method is a safer
+ * alternative to calling {@link Element#getAnnotation} as it avoids any interaction with
+ * annotation proxies.
+ */
+ public static Optional<AnnotationMirror> getAnnotationMirror(
+ Element element, TypeElement annotation) {
+ for (AnnotationMirror elementAnnotation : element.getAnnotationMirrors()) {
+ if (elementAnnotation.getAnnotationType().asElement().equals(annotation)) {
+ return Optional.of(elementAnnotation);
+ }
+ }
+ return Optional.absent();
+ }
+
+ /**
+ * Returns an {@link AnnotationMirror} for the annotation whose type's canonical name is on {@code
+ * element}, or {@link Optional#absent()} if no such annotation exists. This method is a safer
+ * alternative to calling {@link Element#getAnnotation} as it avoids any interaction with
+ * annotation proxies.
+ */
+ public static Optional<AnnotationMirror> getAnnotationMirror(
+ Element element, String annotationName) {
for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
TypeElement annotationTypeElement = asType(annotationMirror.getAnnotationType().asElement());
- if (annotationTypeElement.getQualifiedName().contentEquals(annotationClassName)) {
+ if (annotationTypeElement.getQualifiedName().contentEquals(annotationName)) {
return Optional.of(annotationMirror);
}
}
@@ -435,9 +487,9 @@
}
}
}
- Set<ExecutableElement> methods = new LinkedHashSet<ExecutableElement>(methodMap.values());
- methods.removeAll(overridden);
- return ImmutableSet.copyOf(methods);
+ return methodMap.values().stream()
+ .filter(m -> !overridden.contains(m))
+ .collect(toImmutableSet());
}
// Add to `methods` the static and instance methods from `type`. This means all methods from
diff --git a/common/src/main/java/com/google/auto/common/MoreStreams.java b/common/src/main/java/com/google/auto/common/MoreStreams.java
new file mode 100644
index 0000000..934514a
--- /dev/null
+++ b/common/src/main/java/com/google/auto/common/MoreStreams.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.common;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
+
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+
+/**
+ * A utility class that provides Android compatible alternatives to Guava's streaming APIs.
+ *
+ * <p>This is useful when the Android flavor of Guava somehow finds its way onto the processor
+ * classpath.
+ */
+public final class MoreStreams {
+
+ /** Returns a collector for an {@link ImmutableList}. */
+ public static <T> Collector<T, ?, ImmutableList<T>> toImmutableList() {
+ return collectingAndThen(toList(), ImmutableList::copyOf);
+ }
+
+ /** Returns a collector for an {@link ImmutableSet}. */
+ public static <T> Collector<T, ?, ImmutableSet<T>> toImmutableSet() {
+ return collectingAndThen(toList(), ImmutableSet::copyOf);
+ }
+
+ /** Returns a collector for an {@link ImmutableMap}. */
+ public static <T, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap(
+ Function<? super T, K> keyMapper, Function<? super T, V> valueMapper) {
+ return Collectors.mapping(
+ value -> Maps.immutableEntry(keyMapper.apply(value), valueMapper.apply(value)),
+ Collector.of(
+ ImmutableMap::builder,
+ (ImmutableMap.Builder<K, V> builder, Map.Entry<K, V> entry) -> builder.put(entry),
+ (left, right) -> left.putAll(right.build()),
+ ImmutableMap.Builder::build));
+ }
+
+ /** Returns a collector for an {@link ImmutableBiMap}. */
+ public static <T, K, V> Collector<T, ?, ImmutableBiMap<K, V>> toImmutableBiMap(
+ Function<? super T, K> keyMapper, Function<? super T, V> valueMapper) {
+ return Collectors.mapping(
+ value -> Maps.immutableEntry(keyMapper.apply(value), valueMapper.apply(value)),
+ Collector.of(
+ ImmutableBiMap::builder,
+ (ImmutableBiMap.Builder<K, V> builder, Map.Entry<K, V> entry) -> builder.put(entry),
+ (left, right) -> left.putAll(right.build()),
+ ImmutableBiMap.Builder::build));
+ }
+
+ private MoreStreams() {}
+}
diff --git a/common/src/main/java/com/google/auto/common/MoreTypes.java b/common/src/main/java/com/google/auto/common/MoreTypes.java
index e09680b..1a49062 100644
--- a/common/src/main/java/com/google/auto/common/MoreTypes.java
+++ b/common/src/main/java/com/google/auto/common/MoreTypes.java
@@ -25,7 +25,6 @@
import static javax.lang.model.type.TypeKind.WILDCARD;
import com.google.common.base.Equivalence;
-import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
@@ -55,6 +54,7 @@
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleTypeVisitor8;
import javax.lang.model.util.Types;
+import org.checkerframework.checker.nullness.qual.Nullable;
/**
* Utilities related to {@link TypeMirror} instances.
@@ -75,6 +75,11 @@
protected int doHash(TypeMirror t) {
return MoreTypes.hash(t, ImmutableSet.<Element>of());
}
+
+ @Override
+ public String toString() {
+ return "MoreTypes.equivalence()";
+ }
}
/**
@@ -135,13 +140,11 @@
}
@Override
- public boolean equals(Object o) {
+ public boolean equals(@Nullable Object o) {
if (o instanceof ComparedElements) {
ComparedElements that = (ComparedElements) o;
int nArguments = aArguments.size();
- if (!this.a.equals(that.a)
- || !this.b.equals(that.b)
- || nArguments != bArguments.size()) {
+ if (!this.a.equals(that.a) || !this.b.equals(that.b) || nArguments != bArguments.size()) {
// The arguments must be the same size, but we check anyway.
return false;
}
@@ -294,7 +297,14 @@
}
@SuppressWarnings("TypeEquals")
- private static boolean equal(TypeMirror a, TypeMirror b, Set<ComparedElements> visiting) {
+ private static boolean equal(
+ @Nullable TypeMirror a, @Nullable TypeMirror b, Set<ComparedElements> visiting) {
+ if (a == b) {
+ return true;
+ }
+ if (a == null || b == null) {
+ return false;
+ }
// TypeMirror.equals is not guaranteed to return true for types that are equal, but we can
// assume that if it does return true then the types are equal. This check also avoids getting
// stuck in infinite recursion when Eclipse decrees that the upper bound of the second K in
@@ -302,13 +312,15 @@
// The javac implementation of ExecutableType, at least in some versions, does not take thrown
// exceptions into account in its equals implementation, so avoid this optimization for
// ExecutableType.
- if (Objects.equal(a, b) && !(a instanceof ExecutableType)) {
+ @SuppressWarnings("TypesEquals")
+ boolean equal = a.equals(b);
+ if (equal && !(a instanceof ExecutableType)) {
return true;
}
EqualVisitorParam p = new EqualVisitorParam();
p.type = b;
p.visiting = visiting;
- return (a == b) || (a != null && b != null && a.accept(EqualVisitor.INSTANCE, p));
+ return a.accept(EqualVisitor.INSTANCE, p);
}
/**
@@ -318,7 +330,7 @@
* <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=508222">this bug</a> whereby
* the Eclipse compiler returns a value for static classes that is not NoType.
*/
- private static TypeMirror enclosingType(DeclaredType t) {
+ private static @Nullable TypeMirror enclosingType(DeclaredType t) {
TypeMirror enclosing = t.getEnclosingType();
if (enclosing.getKind().equals(TypeKind.NONE)
|| t.asElement().getModifiers().contains(Modifier.STATIC)) {
@@ -337,16 +349,14 @@
Iterator<? extends TypeMirror> aIterator = a.iterator();
Iterator<? extends TypeMirror> bIterator = b.iterator();
while (aIterator.hasNext()) {
- if (!bIterator.hasNext()) {
- return false;
- }
+ // We checked that the lists have the same size, so we know that bIterator.hasNext() too.
TypeMirror nextMirrorA = aIterator.next();
TypeMirror nextMirrorB = bIterator.next();
if (!equal(nextMirrorA, nextMirrorB, visiting)) {
return false;
}
}
- return !aIterator.hasNext();
+ return true;
}
private static final int HASH_SEED = 17;
@@ -433,7 +443,7 @@
public Integer visitUnknown(TypeMirror t, Set<Element> visiting) {
throw new UnsupportedOperationException();
}
- };
+ }
private static int hashList(List<? extends TypeMirror> mirrors, Set<Element> visiting) {
int result = HASH_SEED;
@@ -460,17 +470,17 @@
}
private static final class ReferencedTypes
- extends SimpleTypeVisitor8<Void, ImmutableSet.Builder<TypeElement>> {
+ extends SimpleTypeVisitor8<@Nullable Void, ImmutableSet.Builder<TypeElement>> {
private static final ReferencedTypes INSTANCE = new ReferencedTypes();
@Override
- public Void visitArray(ArrayType t, ImmutableSet.Builder<TypeElement> p) {
+ public @Nullable Void visitArray(ArrayType t, ImmutableSet.Builder<TypeElement> p) {
t.getComponentType().accept(this, p);
return null;
}
@Override
- public Void visitDeclared(DeclaredType t, ImmutableSet.Builder<TypeElement> p) {
+ public @Nullable Void visitDeclared(DeclaredType t, ImmutableSet.Builder<TypeElement> p) {
p.add(MoreElements.asType(t.asElement()));
for (TypeMirror typeArgument : t.getTypeArguments()) {
typeArgument.accept(this, p);
@@ -479,14 +489,14 @@
}
@Override
- public Void visitTypeVariable(TypeVariable t, ImmutableSet.Builder<TypeElement> p) {
+ public @Nullable Void visitTypeVariable(TypeVariable t, ImmutableSet.Builder<TypeElement> p) {
t.getLowerBound().accept(this, p);
t.getUpperBound().accept(this, p);
return null;
}
@Override
- public Void visitWildcard(WildcardType t, ImmutableSet.Builder<TypeElement> p) {
+ public @Nullable Void visitWildcard(WildcardType t, ImmutableSet.Builder<TypeElement> p) {
TypeMirror extendsBound = t.getExtendsBound();
if (extendsBound != null) {
extendsBound.accept(this, p);
@@ -534,7 +544,8 @@
public Element visitTypeVariable(TypeVariable t, Void p) {
return t.asElement();
}
- };
+ }
+ ;
// TODO(gak): consider removing these two methods as they're pretty trivial now
public static TypeElement asTypeElement(TypeMirror mirror) {
@@ -833,6 +844,11 @@
}
@Override
+ public Boolean visitError(ErrorType errorType, Void p) {
+ return false;
+ }
+
+ @Override
public Boolean visitPrimitive(PrimitiveType type, Void p) {
switch (type.getKind()) {
case BOOLEAN:
@@ -873,11 +889,11 @@
* {@link Optional#absent()} if {@code type} is an interface or {@link Object} or its superclass
* is {@link Object}.
*/
- // TODO(user): Remove unused parameter Elements?
- public static Optional<DeclaredType> nonObjectSuperclass(Types types, Elements elements,
- DeclaredType type) {
+ // TODO(bcorso): Remove unused parameter Elements?
+ public static Optional<DeclaredType> nonObjectSuperclass(
+ Types types, Elements elements, DeclaredType type) {
checkNotNull(types);
- checkNotNull(elements); // This is no longer used, but here to avoid changing the API.
+ checkNotNull(elements); // This is no longer used, but here to avoid changing the API.
checkNotNull(type);
TypeMirror superclassType = asTypeElement(type).getSuperclass();
@@ -885,7 +901,7 @@
return Optional.absent();
}
- DeclaredType superclass = asDeclared(superclassType);
+ DeclaredType superclass = asDeclared(superclassType);
if (isObjectType(superclass)) {
return Optional.absent();
}
@@ -912,8 +928,8 @@
* {@code container} of type {@code Set<String>}, and a variable corresponding to the {@code E e}
* parameter in the {@code Set.add(E e)} method, this will return a TypeMirror for {@code String}.
*/
- public static TypeMirror asMemberOf(Types types, DeclaredType container,
- VariableElement variable) {
+ public static TypeMirror asMemberOf(
+ Types types, DeclaredType container, VariableElement variable) {
if (variable.getKind().equals(ElementKind.PARAMETER)) {
ExecutableElement methodOrConstructor =
MoreElements.asExecutable(variable.getEnclosingElement());
diff --git a/common/src/main/java/com/google/auto/common/Overrides.java b/common/src/main/java/com/google/auto/common/Overrides.java
index 19a4586..775c304 100644
--- a/common/src/main/java/com/google/auto/common/Overrides.java
+++ b/common/src/main/java/com/google/auto/common/Overrides.java
@@ -15,6 +15,8 @@
*/
package com.google.auto.common;
+import static java.util.stream.Collectors.toList;
+
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.collect.ImmutableList;
@@ -38,6 +40,7 @@
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleTypeVisitor8;
import javax.lang.model.util.Types;
+import org.checkerframework.checker.nullness.qual.Nullable;
/**
* Determines if one method overrides another. This class defines two ways of doing that:
@@ -114,12 +117,11 @@
// can't be overridden.
return false;
}
- TypeElement overriddenType;
if (!(overridden.getEnclosingElement() instanceof TypeElement)) {
return false;
// We don't know how this could happen but we avoid blowing up if it does.
}
- overriddenType = MoreElements.asType(overridden.getEnclosingElement());
+ TypeElement overriddenType = MoreElements.asType(overridden.getEnclosingElement());
// We erase the types before checking subtypes, because the TypeMirror we get for List<E> is
// not a subtype of the one we get for Collection<E> since the two E instances are not the
// same. For the purposes of overriding, type parameters in the containing type should not
@@ -141,7 +143,8 @@
// the enclosing elements rather than the methods themselves for the reason described
// at the start of the method.
ExecutableElement inherited = methodFromSuperclasses(in, overridden);
- return !overridden.getEnclosingElement().equals(inherited.getEnclosingElement());
+ return inherited != null
+ && !overridden.getEnclosingElement().equals(inherited.getEnclosingElement());
} else if (overriddenType.getKind().isInterface()) {
// ...overrides from C another method mI declared in interface I. We've already checked
// the conditions (assuming that the only alternative to mI being abstract or default is
@@ -157,7 +160,8 @@
// to methodFromSuperclasses above.
if (overrider.getModifiers().contains(Modifier.ABSTRACT)) {
ExecutableElement inherited = methodFromSuperinterfaces(in, overridden);
- return !overridden.getEnclosingElement().equals(inherited.getEnclosingElement());
+ return inherited != null
+ && !overridden.getEnclosingElement().equals(inherited.getEnclosingElement());
} else {
return true;
}
@@ -215,6 +219,7 @@
* implements List<E>}. The parameter types are erased since the purpose of this method is to
* determine whether two methods are candidates for one to override the other.
*/
+ @Nullable
ImmutableList<TypeMirror> erasedParameterTypes(ExecutableElement method, TypeElement in) {
if (method.getParameters().isEmpty()) {
return ImmutableList.of();
@@ -241,6 +246,7 @@
*/
private final Map<TypeParameterElement, TypeMirror> typeBindings = Maps.newLinkedHashMap();
+ @Nullable
ImmutableList<TypeMirror> erasedParameterTypes(ExecutableElement method, TypeElement in) {
if (method.getEnclosingElement().equals(in)) {
ImmutableList.Builder<TypeMirror> params = ImmutableList.builder();
@@ -261,6 +267,10 @@
TypeElement element = MoreElements.asType(declared.asElement());
List<? extends TypeMirror> actuals = declared.getTypeArguments();
List<? extends TypeParameterElement> formals = element.getTypeParameters();
+ if (actuals.isEmpty()) {
+ // Either the formal type arguments are also empty or `declared` is raw.
+ actuals = formals.stream().map(t -> t.getBounds().get(0)).collect(toList());
+ }
Verify.verify(actuals.size() == formals.size());
for (int i = 0; i < actuals.size(); i++) {
typeBindings.put(formals.get(i), actuals.get(i));
@@ -315,7 +325,7 @@
* or the nearest override in a superclass of the given type, or null if the method is not
* found in the given type or any of its superclasses.
*/
- ExecutableElement methodFromSuperclasses(TypeElement in, ExecutableElement method) {
+ @Nullable ExecutableElement methodFromSuperclasses(TypeElement in, ExecutableElement method) {
for (TypeElement t = in; t != null; t = superclass(t)) {
ExecutableElement tMethod = methodInType(t, method);
if (tMethod != null) {
@@ -330,6 +340,7 @@
* itself, or the nearest override in a superinterface of the given type, or null if the method
* is not found in the given type or any of its transitive superinterfaces.
*/
+ @Nullable
ExecutableElement methodFromSuperinterfaces(TypeElement in, ExecutableElement method) {
TypeElement methodContainer = MoreElements.asType(method.getEnclosingElement());
Preconditions.checkArgument(methodContainer.getKind().isInterface());
@@ -366,7 +377,7 @@
* Returns the method from within the given type that has the same erased signature as the given
* method, or null if there is no such method.
*/
- private ExecutableElement methodInType(TypeElement type, ExecutableElement method) {
+ private @Nullable ExecutableElement methodInType(TypeElement type, ExecutableElement method) {
int nParams = method.getParameters().size();
List<TypeMirror> params = erasedParameterTypes(method, type);
if (params == null) {
@@ -388,7 +399,7 @@
return null;
}
- private TypeElement superclass(TypeElement type) {
+ private @Nullable TypeElement superclass(TypeElement type) {
TypeMirror sup = type.getSuperclass();
if (sup.getKind() == TypeKind.DECLARED) {
return MoreElements.asType(typeUtils.asElement(sup));
diff --git a/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java b/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java
index 7d508e3..7952eb3 100644
--- a/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java
+++ b/common/src/main/java/com/google/auto/common/SimpleAnnotationMirror.java
@@ -16,8 +16,8 @@
package com.google.auto.common;
+import static com.google.auto.common.MoreStreams.toImmutableMap;
import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.ImmutableMap.toImmutableMap;
import static javax.lang.model.util.ElementFilter.methodsIn;
import com.google.common.base.Joiner;
@@ -32,6 +32,7 @@
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.DeclaredType;
+import org.checkerframework.checker.nullness.qual.Nullable;
/**
* A simple implementation of the {@link AnnotationMirror} interface.
@@ -65,7 +66,7 @@
missingMembers.add(memberName);
}
}
-
+
checkArgument(
unusedValues.isEmpty(),
"namedValues has entries for members that are not in %s: %s",
@@ -77,8 +78,7 @@
this.annotationType = annotationType;
this.namedValues = ImmutableMap.copyOf(namedValues);
this.elementValues =
- methodsIn(annotationType.getEnclosedElements())
- .stream()
+ methodsIn(annotationType.getEnclosedElements()).stream()
.collect(toImmutableMap(e -> e, e -> values.get(e.getSimpleName().toString())));
}
@@ -123,7 +123,7 @@
}
@Override
- public boolean equals(Object other) {
+ public boolean equals(@Nullable Object other) {
return other instanceof AnnotationMirror
&& AnnotationMirrors.equivalence().equivalent(this, (AnnotationMirror) other);
}
diff --git a/common/src/main/java/com/google/auto/common/SuperficialValidation.java b/common/src/main/java/com/google/auto/common/SuperficialValidation.java
index 5ef4dbf..614e262 100644
--- a/common/src/main/java/com/google/auto/common/SuperficialValidation.java
+++ b/common/src/main/java/com/google/auto/common/SuperficialValidation.java
@@ -57,23 +57,27 @@
private static final ElementVisitor<Boolean, Void> ELEMENT_VALIDATING_VISITOR =
new AbstractElementVisitor8<Boolean, Void>() {
- @Override public Boolean visitPackage(PackageElement e, Void p) {
+ @Override
+ public Boolean visitPackage(PackageElement e, Void p) {
// don't validate enclosed elements because it will return types in the package
return validateAnnotations(e.getAnnotationMirrors());
}
- @Override public Boolean visitType(TypeElement e, Void p) {
+ @Override
+ public Boolean visitType(TypeElement e, Void p) {
return isValidBaseElement(e)
&& validateElements(e.getTypeParameters())
&& validateTypes(e.getInterfaces())
&& validateType(e.getSuperclass());
}
- @Override public Boolean visitVariable(VariableElement e, Void p) {
+ @Override
+ public Boolean visitVariable(VariableElement e, Void p) {
return isValidBaseElement(e);
}
- @Override public Boolean visitExecutable(ExecutableElement e, Void p) {
+ @Override
+ public Boolean visitExecutable(ExecutableElement e, Void p) {
AnnotationValue defaultValue = e.getDefaultValue();
return isValidBaseElement(e)
&& (defaultValue == null || validateAnnotationValue(defaultValue, e.getReturnType()))
@@ -83,12 +87,13 @@
&& validateElements(e.getParameters());
}
- @Override public Boolean visitTypeParameter(TypeParameterElement e, Void p) {
- return isValidBaseElement(e)
- && validateTypes(e.getBounds());
+ @Override
+ public Boolean visitTypeParameter(TypeParameterElement e, Void p) {
+ return isValidBaseElement(e) && validateTypes(e.getBounds());
}
- @Override public Boolean visitUnknown(Element e, Void p) {
+ @Override
+ public Boolean visitUnknown(Element e, Void p) {
// just assume that unknown elements are OK
return true;
}
@@ -206,16 +211,19 @@
private static final AnnotationValueVisitor<Boolean, TypeMirror> VALUE_VALIDATING_VISITOR =
new SimpleAnnotationValueVisitor8<Boolean, TypeMirror>() {
- @Override protected Boolean defaultAction(Object o, TypeMirror expectedType) {
+ @Override
+ protected Boolean defaultAction(Object o, TypeMirror expectedType) {
return MoreTypes.isTypeOf(o.getClass(), expectedType);
}
- @Override public Boolean visitUnknown(AnnotationValue av, TypeMirror expectedType) {
+ @Override
+ public Boolean visitUnknown(AnnotationValue av, TypeMirror expectedType) {
// just take the default action for the unknown
return defaultAction(av, expectedType);
}
- @Override public Boolean visitAnnotation(AnnotationMirror a, TypeMirror expectedType) {
+ @Override
+ public Boolean visitAnnotation(AnnotationMirror a, TypeMirror expectedType) {
return MoreTypes.equivalence().equivalent(a.getAnnotationType(), expectedType)
&& validateAnnotation(a);
}
@@ -235,7 +243,8 @@
&& validateElement(enumConstant);
}
- @Override public Boolean visitType(TypeMirror type, TypeMirror ignored) {
+ @Override
+ public Boolean visitType(TypeMirror type, TypeMirror ignored) {
// We could check assignability here, but would require a Types instance. Since this
// isn't really the sort of thing that shows up in a bad AST from upstream compilation
// we ignore the expected type and just validate the type. It might be wrong, but
@@ -243,35 +252,43 @@
return validateType(type);
}
- @Override public Boolean visitBoolean(boolean b, TypeMirror expectedType) {
+ @Override
+ public Boolean visitBoolean(boolean b, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Boolean.TYPE, expectedType);
}
- @Override public Boolean visitByte(byte b, TypeMirror expectedType) {
+ @Override
+ public Boolean visitByte(byte b, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Byte.TYPE, expectedType);
}
- @Override public Boolean visitChar(char c, TypeMirror expectedType) {
+ @Override
+ public Boolean visitChar(char c, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Character.TYPE, expectedType);
}
- @Override public Boolean visitDouble(double d, TypeMirror expectedType) {
+ @Override
+ public Boolean visitDouble(double d, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Double.TYPE, expectedType);
}
- @Override public Boolean visitFloat(float f, TypeMirror expectedType) {
+ @Override
+ public Boolean visitFloat(float f, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Float.TYPE, expectedType);
}
- @Override public Boolean visitInt(int i, TypeMirror expectedType) {
+ @Override
+ public Boolean visitInt(int i, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Integer.TYPE, expectedType);
}
- @Override public Boolean visitLong(long l, TypeMirror expectedType) {
+ @Override
+ public Boolean visitLong(long l, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Long.TYPE, expectedType);
}
- @Override public Boolean visitShort(short s, TypeMirror expectedType) {
+ @Override
+ public Boolean visitShort(short s, TypeMirror expectedType) {
return MoreTypes.isTypeOf(Short.TYPE, expectedType);
}
};
diff --git a/common/src/main/java/com/google/auto/common/Visibility.java b/common/src/main/java/com/google/auto/common/Visibility.java
index f82fdd5..36f4ad6 100644
--- a/common/src/main/java/com/google/auto/common/Visibility.java
+++ b/common/src/main/java/com/google/auto/common/Visibility.java
@@ -16,14 +16,15 @@
package com.google.auto.common;
import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Comparators.min;
import static javax.lang.model.element.ElementKind.PACKAGE;
import com.google.common.base.Enums;
-import com.google.common.collect.Ordering;
import java.util.Set;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.Modifier;
+import org.checkerframework.checker.nullness.qual.Nullable;
/**
* Represents the visibility of a given {@link Element}: {@code public}, {@code protected},
@@ -41,7 +42,7 @@
// TODO(ronshapiro): remove this and reference ElementKind.MODULE directly once we start building
// with -source 9
- private static final ElementKind MODULE =
+ private static final @Nullable ElementKind MODULE =
Enums.getIfPresent(ElementKind.class, "MODULE").orNull();
/**
@@ -76,8 +77,7 @@
Visibility effectiveVisibility = PUBLIC;
Element currentElement = element;
while (currentElement != null) {
- effectiveVisibility =
- Ordering.natural().min(effectiveVisibility, ofElement(currentElement));
+ effectiveVisibility = min(effectiveVisibility, ofElement(currentElement));
currentElement = currentElement.getEnclosingElement();
}
return effectiveVisibility;
diff --git a/common/src/main/java/com/google/auto/common/package-info.java b/common/src/main/java/com/google/auto/common/package-info.java
new file mode 100644
index 0000000..22b0c45
--- /dev/null
+++ b/common/src/main/java/com/google/auto/common/package-info.java
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.common;
+
diff --git a/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java b/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java
index dfc043a..b1dfe3b 100644
--- a/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java
+++ b/common/src/test/java/com/google/auto/common/AnnotationMirrorsTest.java
@@ -22,12 +22,17 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static org.junit.Assert.fail;
+import com.google.common.collect.ImmutableSet;
import com.google.common.testing.EquivalenceTester;
+import com.google.common.truth.Correspondence;
import com.google.testing.compile.CompilationRule;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
import java.util.Map;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleAnnotationValueVisitor6;
@@ -46,110 +51,134 @@
private Elements elements;
- @Before public void setUp() {
+ @Before
+ public void setUp() {
this.elements = compilationRule.getElements();
}
@interface SimpleAnnotation {}
- @SimpleAnnotation class SimplyAnnotated {}
- @SimpleAnnotation class AlsoSimplyAnnotated {}
+ @SimpleAnnotation
+ static class SimplyAnnotated {}
+
+ @SimpleAnnotation
+ static class AlsoSimplyAnnotated {}
enum SimpleEnum {
- BLAH, FOO
+ BLAH,
+ FOO
}
@interface Outer {
SimpleEnum value();
}
- @Outer(BLAH) static class TestClassBlah {}
- @Outer(BLAH) static class TestClassBlah2 {}
- @Outer(FOO) static class TestClassFoo {}
+ @Outer(BLAH)
+ static class TestClassBlah {}
+
+ @Outer(BLAH)
+ static class TestClassBlah2 {}
+
+ @Outer(FOO)
+ static class TestClassFoo {}
@interface DefaultingOuter {
SimpleEnum value() default SimpleEnum.BLAH;
}
- @DefaultingOuter class TestWithDefaultingOuterDefault {}
- @DefaultingOuter(BLAH) class TestWithDefaultingOuterBlah {}
- @DefaultingOuter(FOO) class TestWithDefaultingOuterFoo {}
+ @DefaultingOuter
+ static class TestWithDefaultingOuterDefault {}
+
+ @DefaultingOuter(BLAH)
+ static class TestWithDefaultingOuterBlah {}
+
+ @DefaultingOuter(FOO)
+ static class TestWithDefaultingOuterFoo {}
@interface AnnotatedOuter {
DefaultingOuter value();
}
- @AnnotatedOuter(@DefaultingOuter) class TestDefaultNestedAnnotated {}
- @AnnotatedOuter(@DefaultingOuter(BLAH)) class TestBlahNestedAnnotated {}
- @AnnotatedOuter(@DefaultingOuter(FOO)) class TestFooNestedAnnotated {}
+ @AnnotatedOuter(@DefaultingOuter)
+ static class TestDefaultNestedAnnotated {}
+
+ @AnnotatedOuter(@DefaultingOuter(BLAH))
+ static class TestBlahNestedAnnotated {}
+
+ @AnnotatedOuter(@DefaultingOuter(FOO))
+ static class TestFooNestedAnnotated {}
@interface OuterWithValueArray {
DefaultingOuter[] value() default {};
}
- @OuterWithValueArray class TestValueArrayWithDefault {}
- @OuterWithValueArray({}) class TestValueArrayWithEmpty {}
+ @OuterWithValueArray
+ static class TestValueArrayWithDefault {}
- @OuterWithValueArray({@DefaultingOuter}) class TestValueArrayWithOneDefault {}
- @OuterWithValueArray(@DefaultingOuter(BLAH)) class TestValueArrayWithOneBlah {}
- @OuterWithValueArray(@DefaultingOuter(FOO)) class TestValueArrayWithOneFoo {}
+ @OuterWithValueArray({})
+ static class TestValueArrayWithEmpty {}
+
+ @OuterWithValueArray({@DefaultingOuter})
+ static class TestValueArrayWithOneDefault {}
+
+ @OuterWithValueArray(@DefaultingOuter(BLAH))
+ static class TestValueArrayWithOneBlah {}
+
+ @OuterWithValueArray(@DefaultingOuter(FOO))
+ static class TestValueArrayWithOneFoo {}
@OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter})
class TestValueArrayWithFooAndDefaultBlah {}
+
@OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter(BLAH)})
class TestValueArrayWithFooBlah {}
+
@OuterWithValueArray({@DefaultingOuter(FOO), @DefaultingOuter(BLAH)})
class TestValueArrayWithFooBlah2 {} // Different instances than on TestValueArrayWithFooBlah.
+
@OuterWithValueArray({@DefaultingOuter(BLAH), @DefaultingOuter(FOO)})
class TestValueArrayWithBlahFoo {}
- @Test public void testEquivalences() {
+ @Test
+ public void testEquivalences() {
EquivalenceTester<AnnotationMirror> tester =
EquivalenceTester.of(AnnotationMirrors.equivalence());
tester.addEquivalenceGroup(
- annotationOn(SimplyAnnotated.class),
- annotationOn(AlsoSimplyAnnotated.class));
+ annotationOn(SimplyAnnotated.class), annotationOn(AlsoSimplyAnnotated.class));
tester.addEquivalenceGroup(
- annotationOn(TestClassBlah.class),
- annotationOn(TestClassBlah2.class));
+ annotationOn(TestClassBlah.class), annotationOn(TestClassBlah2.class));
- tester.addEquivalenceGroup(
- annotationOn(TestClassFoo.class));
+ tester.addEquivalenceGroup(annotationOn(TestClassFoo.class));
tester.addEquivalenceGroup(
annotationOn(TestWithDefaultingOuterDefault.class),
annotationOn(TestWithDefaultingOuterBlah.class));
- tester.addEquivalenceGroup(
- annotationOn(TestWithDefaultingOuterFoo.class));
+ tester.addEquivalenceGroup(annotationOn(TestWithDefaultingOuterFoo.class));
tester.addEquivalenceGroup(
annotationOn(TestDefaultNestedAnnotated.class),
annotationOn(TestBlahNestedAnnotated.class));
- tester.addEquivalenceGroup(
- annotationOn(TestFooNestedAnnotated.class));
+ tester.addEquivalenceGroup(annotationOn(TestFooNestedAnnotated.class));
tester.addEquivalenceGroup(
- annotationOn(TestValueArrayWithDefault.class),
- annotationOn(TestValueArrayWithEmpty.class));
+ annotationOn(TestValueArrayWithDefault.class), annotationOn(TestValueArrayWithEmpty.class));
tester.addEquivalenceGroup(
annotationOn(TestValueArrayWithOneDefault.class),
annotationOn(TestValueArrayWithOneBlah.class));
- tester.addEquivalenceGroup(
- annotationOn(TestValueArrayWithOneFoo.class));
+ tester.addEquivalenceGroup(annotationOn(TestValueArrayWithOneFoo.class));
tester.addEquivalenceGroup(
annotationOn(TestValueArrayWithFooAndDefaultBlah.class),
annotationOn(TestValueArrayWithFooBlah.class),
annotationOn(TestValueArrayWithFooBlah2.class));
- tester.addEquivalenceGroup(
- annotationOn(TestValueArrayWithBlahFoo.class));
+ tester.addEquivalenceGroup(annotationOn(TestValueArrayWithBlahFoo.class));
tester.test();
}
@@ -158,44 +187,61 @@
String value() default "default";
}
- @Stringy class StringyUnset {}
- @Stringy("foo") class StringySet {}
+ @Stringy
+ static class StringyUnset {}
- @Test public void testGetDefaultValuesUnset() {
+ @Stringy("foo")
+ static class StringySet {}
+
+ @Test
+ public void testGetDefaultValuesUnset() {
assertThat(annotationOn(StringyUnset.class).getElementValues()).isEmpty();
- Iterable<AnnotationValue> values = AnnotationMirrors.getAnnotationValuesWithDefaults(
- annotationOn(StringyUnset.class)).values();
- String value = getOnlyElement(values).accept(new SimpleAnnotationValueVisitor6<String, Void>() {
- @Override public String visitString(String value, Void ignored) {
- return value;
- }
- }, null);
+ Iterable<AnnotationValue> values =
+ AnnotationMirrors.getAnnotationValuesWithDefaults(annotationOn(StringyUnset.class))
+ .values();
+ String value =
+ getOnlyElement(values)
+ .accept(
+ new SimpleAnnotationValueVisitor6<String, Void>() {
+ @Override
+ public String visitString(String value, Void ignored) {
+ return value;
+ }
+ },
+ null);
assertThat(value).isEqualTo("default");
}
- @Test public void testGetDefaultValuesSet() {
- Iterable<AnnotationValue> values = AnnotationMirrors.getAnnotationValuesWithDefaults(
- annotationOn(StringySet.class)).values();
- String value = getOnlyElement(values).accept(new SimpleAnnotationValueVisitor6<String, Void>() {
- @Override public String visitString(String value, Void ignored) {
- return value;
- }
- }, null);
+ @Test
+ public void testGetDefaultValuesSet() {
+ Iterable<AnnotationValue> values =
+ AnnotationMirrors.getAnnotationValuesWithDefaults(annotationOn(StringySet.class)).values();
+ String value =
+ getOnlyElement(values)
+ .accept(
+ new SimpleAnnotationValueVisitor6<String, Void>() {
+ @Override
+ public String visitString(String value, Void ignored) {
+ return value;
+ }
+ },
+ null);
assertThat(value).isEqualTo("foo");
}
- @Test public void testGetValueEntry() {
+ @Test
+ public void testGetValueEntry() {
Map.Entry<ExecutableElement, AnnotationValue> elementValue =
- AnnotationMirrors.getAnnotationElementAndValue(
- annotationOn(TestClassBlah.class), "value");
+ AnnotationMirrors.getAnnotationElementAndValue(annotationOn(TestClassBlah.class), "value");
assertThat(elementValue.getKey().getSimpleName().toString()).isEqualTo("value");
assertThat(elementValue.getValue().getValue()).isInstanceOf(VariableElement.class);
- AnnotationValue value = AnnotationMirrors.getAnnotationValue(
- annotationOn(TestClassBlah.class), "value");
+ AnnotationValue value =
+ AnnotationMirrors.getAnnotationValue(annotationOn(TestClassBlah.class), "value");
assertThat(value.getValue()).isInstanceOf(VariableElement.class);
}
- @Test public void testGetValueEntryFailure() {
+ @Test
+ public void testGetValueEntryFailure() {
try {
AnnotationMirrors.getAnnotationValue(annotationOn(TestClassBlah.class), "a");
} catch (IllegalArgumentException e) {
@@ -212,4 +258,52 @@
return getOnlyElement(elements.getTypeElement(clazz.getCanonicalName()).getAnnotationMirrors());
}
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface AnnotatingAnnotation {}
+
+ @AnnotatingAnnotation
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface AnnotatedAnnotation1 {}
+
+ @AnnotatingAnnotation
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface AnnotatedAnnotation2 {}
+
+ @Retention(RetentionPolicy.RUNTIME)
+ private @interface NotAnnotatedAnnotation {}
+
+ @AnnotatedAnnotation1
+ @NotAnnotatedAnnotation
+ @AnnotatedAnnotation2
+ private static final class AnnotatedClass {}
+
+ @Test
+ public void getAnnotatedAnnotations() {
+ TypeElement element = elements.getTypeElement(AnnotatedClass.class.getCanonicalName());
+
+ // Test Class API
+ getAnnotatedAnnotationsAsserts(
+ AnnotationMirrors.getAnnotatedAnnotations(element, AnnotatingAnnotation.class));
+
+ // Test String API
+ String annotatingAnnotationName = AnnotatingAnnotation.class.getCanonicalName();
+ getAnnotatedAnnotationsAsserts(
+ AnnotationMirrors.getAnnotatedAnnotations(element, annotatingAnnotationName));
+
+ // Test TypeElement API
+ TypeElement annotatingAnnotationElement = elements.getTypeElement(annotatingAnnotationName);
+ getAnnotatedAnnotationsAsserts(
+ AnnotationMirrors.getAnnotatedAnnotations(element, annotatingAnnotationElement));
+ }
+
+ private void getAnnotatedAnnotationsAsserts(
+ ImmutableSet<? extends AnnotationMirror> annotatedAnnotations) {
+ assertThat(annotatedAnnotations)
+ .comparingElementsUsing(
+ Correspondence.transforming(
+ (AnnotationMirror a) -> MoreTypes.asTypeElement(a.getAnnotationType()), "has type"))
+ .containsExactly(
+ elements.getTypeElement(AnnotatedAnnotation1.class.getCanonicalName()),
+ elements.getTypeElement(AnnotatedAnnotation2.class.getCanonicalName()));
+ }
}
diff --git a/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java b/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java
index 1c816c1..f942652 100644
--- a/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java
+++ b/common/src/test/java/com/google/auto/common/GeneratedAnnotationsTest.java
@@ -18,6 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Objects.requireNonNull;
import static org.junit.Assume.assumeTrue;
import com.google.common.collect.ImmutableList;
@@ -31,6 +32,7 @@
import java.lang.reflect.Method;
import java.net.URI;
import java.nio.file.Files;
+import java.util.Objects;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
@@ -44,6 +46,7 @@
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
+import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
@@ -99,12 +102,12 @@
* Run {@link TestProcessor} in a compilation with the given {@code options}, and prevent the
* compilation from accessing classes with the qualified names in {@code maskFromClasspath}.
*/
- private String runProcessor(ImmutableList<String> options, String packageToMask)
+ private String runProcessor(ImmutableList<String> options, @Nullable String packageToMask)
throws IOException {
File tempDir = temporaryFolder.newFolder();
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager standardFileManager =
- compiler.getStandardFileManager(/* diagnostics= */ null, /* locale= */ null, UTF_8);
+ compiler.getStandardFileManager(/* diagnosticListener= */ null, /* locale= */ null, UTF_8);
standardFileManager.setLocation(StandardLocation.CLASS_OUTPUT, ImmutableList.of(tempDir));
StandardJavaFileManager proxyFileManager =
Reflection.newProxy(
@@ -142,18 +145,20 @@
*/
private static class FileManagerInvocationHandler implements InvocationHandler {
private final StandardJavaFileManager fileManager;
- private final String packageToMask;
+ private final @Nullable String packageToMask;
- FileManagerInvocationHandler(StandardJavaFileManager fileManager, String packageToMask) {
+ FileManagerInvocationHandler(
+ StandardJavaFileManager fileManager, @Nullable String packageToMask) {
this.fileManager = fileManager;
this.packageToMask = packageToMask;
}
@Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ public Object invoke(Object proxy, Method method, @Nullable Object @Nullable [] args)
+ throws Throwable {
if (method.getName().equals("list")) {
- String packageName = (String) args[1];
- if (packageName.equals(packageToMask)) {
+ String packageName = (String) requireNonNull(args)[1];
+ if (Objects.equals(packageName, packageToMask)) {
return ImmutableList.of();
}
}
@@ -187,8 +192,7 @@
// An alternative would be to delete this test method. JDK8 always has
// javax.annotation.Generated so it isn't really meaningful to test it without.
ImmutableList<String> options = ImmutableList.of("-source", "8", "-target", "8");
- String generated =
- runProcessor(options, "javax.annotation");
+ String generated = runProcessor(options, "javax.annotation");
assertThat(generated).doesNotContain(JAVAX_ANNOTATION_GENERATED);
assertThat(generated).doesNotContain(JAVAX_ANNOTATION_PROCESSING_GENERATED);
}
diff --git a/common/src/test/java/com/google/auto/common/MoreElementsTest.java b/common/src/test/java/com/google/auto/common/MoreElementsTest.java
index 95043cf..b98b79b 100644
--- a/common/src/test/java/com/google/auto/common/MoreElementsTest.java
+++ b/common/src/test/java/com/google/auto/common/MoreElementsTest.java
@@ -18,6 +18,7 @@
import static com.google.common.collect.Iterables.getOnlyElement;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
+import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@@ -58,13 +59,14 @@
@Rule public CompilationRule compilation = new CompilationRule();
@Rule public Expect expect = Expect.create();
+ private Elements elements;
private PackageElement javaLangPackageElement;
private TypeElement objectElement;
private TypeElement stringElement;
@Before
public void initializeTestElements() {
- Elements elements = compilation.getElements();
+ this.elements = compilation.getElements();
this.javaLangPackageElement = elements.getPackageElement("java.lang");
this.objectElement = elements.getTypeElement(Object.class.getCanonicalName());
this.stringElement = elements.getTypeElement(String.class.getCanonicalName());
@@ -80,8 +82,7 @@
@Test
public void asPackage() {
- assertThat(MoreElements.asPackage(javaLangPackageElement))
- .isEqualTo(javaLangPackageElement);
+ assertThat(MoreElements.asPackage(javaLangPackageElement)).isEqualTo(javaLangPackageElement);
}
@Test
@@ -89,19 +90,20 @@
try {
MoreElements.asPackage(stringElement);
fail();
- } catch (IllegalArgumentException expected) {}
+ } catch (IllegalArgumentException expected) {
+ }
}
- @Test public void asTypeElement() {
- Element typeElement =
- compilation.getElements().getTypeElement(String.class.getCanonicalName());
+ @Test
+ public void asTypeElement() {
+ Element typeElement = elements.getTypeElement(String.class.getCanonicalName());
assertTrue(MoreElements.isType(typeElement));
assertThat(MoreElements.asType(typeElement)).isEqualTo(typeElement);
}
- @Test public void asTypeElement_notATypeElement() {
- TypeElement typeElement =
- compilation.getElements().getTypeElement(String.class.getCanonicalName());
+ @Test
+ public void asTypeElement_notATypeElement() {
+ TypeElement typeElement = elements.getTypeElement(String.class.getCanonicalName());
for (ExecutableElement e : ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
assertFalse(MoreElements.isType(e));
try {
@@ -143,7 +145,8 @@
try {
MoreElements.asType(javaLangPackageElement);
fail();
- } catch (IllegalArgumentException expected) {}
+ } catch (IllegalArgumentException expected) {
+ }
}
@Test
@@ -158,7 +161,8 @@
try {
MoreElements.asVariable(javaLangPackageElement);
fail();
- } catch (IllegalArgumentException expected) {}
+ } catch (IllegalArgumentException expected) {
+ }
}
@Test
@@ -166,8 +170,8 @@
for (Element methodElement : ElementFilter.methodsIn(stringElement.getEnclosedElements())) {
assertThat(MoreElements.asExecutable(methodElement)).isEqualTo(methodElement);
}
- for (Element methodElement
- : ElementFilter.constructorsIn(stringElement.getEnclosedElements())) {
+ for (Element methodElement :
+ ElementFilter.constructorsIn(stringElement.getEnclosedElements())) {
assertThat(MoreElements.asExecutable(methodElement)).isEqualTo(methodElement);
}
}
@@ -177,7 +181,8 @@
try {
MoreElements.asExecutable(javaLangPackageElement);
fail();
- } catch (IllegalArgumentException expected) {}
+ } catch (IllegalArgumentException expected) {
+ }
}
@Retention(RetentionPolicy.RUNTIME)
@@ -190,39 +195,90 @@
@Test
public void isAnnotationPresent() {
TypeElement annotatedAnnotationElement =
- compilation.getElements().getTypeElement(AnnotatedAnnotation.class.getCanonicalName());
- assertThat(MoreElements.isAnnotationPresent(annotatedAnnotationElement, Documented.class))
- .isTrue();
- assertThat(MoreElements.isAnnotationPresent(annotatedAnnotationElement, InnerAnnotation.class))
- .isTrue();
- assertThat(MoreElements.isAnnotationPresent(annotatedAnnotationElement, SuppressWarnings.class))
- .isFalse();
+ elements.getTypeElement(AnnotatedAnnotation.class.getCanonicalName());
+
+ // Test Class API
+ isAnnotationPresentAsserts(
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, Documented.class),
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, InnerAnnotation.class),
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, SuppressWarnings.class));
+
+ // Test String API
+ String documentedName = Documented.class.getCanonicalName();
+ String innerAnnotationName = InnerAnnotation.class.getCanonicalName();
+ String suppressWarningsName = SuppressWarnings.class.getCanonicalName();
+ isAnnotationPresentAsserts(
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, documentedName),
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, innerAnnotationName),
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, suppressWarningsName));
+
+ // Test TypeElement API
+ TypeElement documentedElement = elements.getTypeElement(documentedName);
+ TypeElement innerAnnotationElement = elements.getTypeElement(innerAnnotationName);
+ TypeElement suppressWarningsElement = elements.getTypeElement(suppressWarningsName);
+ isAnnotationPresentAsserts(
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, documentedElement),
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, innerAnnotationElement),
+ MoreElements.isAnnotationPresent(annotatedAnnotationElement, suppressWarningsElement));
+ }
+
+ private void isAnnotationPresentAsserts(
+ boolean isDocumentedPresent,
+ boolean isInnerAnnotationPresent,
+ boolean isSuppressWarningsPresent) {
+ assertThat(isDocumentedPresent).isTrue();
+ assertThat(isInnerAnnotationPresent).isTrue();
+ assertThat(isSuppressWarningsPresent).isFalse();
}
@Test
public void getAnnotationMirror() {
TypeElement element =
- compilation.getElements().getTypeElement(AnnotatedAnnotation.class.getCanonicalName());
+ elements.getTypeElement(AnnotatedAnnotation.class.getCanonicalName());
- Optional<AnnotationMirror> documented =
- MoreElements.getAnnotationMirror(element, Documented.class);
- Optional<AnnotationMirror> innerAnnotation =
- MoreElements.getAnnotationMirror(element, InnerAnnotation.class);
- Optional<AnnotationMirror> suppressWarnings =
- MoreElements.getAnnotationMirror(element, SuppressWarnings.class);
+ // Test Class API
+ getAnnotationMirrorAsserts(
+ MoreElements.getAnnotationMirror(element, Documented.class),
+ MoreElements.getAnnotationMirror(element, InnerAnnotation.class),
+ MoreElements.getAnnotationMirror(element, SuppressWarnings.class));
+ // Test String API
+ String documentedName = Documented.class.getCanonicalName();
+ String innerAnnotationName = InnerAnnotation.class.getCanonicalName();
+ String suppressWarningsName = SuppressWarnings.class.getCanonicalName();
+ getAnnotationMirrorAsserts(
+ MoreElements.getAnnotationMirror(element, documentedName),
+ MoreElements.getAnnotationMirror(element, innerAnnotationName),
+ MoreElements.getAnnotationMirror(element, suppressWarningsName));
+
+ // Test TypeElement API
+ TypeElement documentedElement = elements.getTypeElement(documentedName);
+ TypeElement innerAnnotationElement = elements.getTypeElement(innerAnnotationName);
+ TypeElement suppressWarningsElement = elements.getTypeElement(suppressWarningsName);
+ getAnnotationMirrorAsserts(
+ MoreElements.getAnnotationMirror(element, documentedElement),
+ MoreElements.getAnnotationMirror(element, innerAnnotationElement),
+ MoreElements.getAnnotationMirror(element, suppressWarningsElement));
+ }
+
+ private void getAnnotationMirrorAsserts(
+ Optional<AnnotationMirror> documented,
+ Optional<AnnotationMirror> innerAnnotation,
+ Optional<AnnotationMirror> suppressWarnings) {
expect.that(documented).isPresent();
expect.that(innerAnnotation).isPresent();
expect.that(suppressWarnings).isAbsent();
Element annotationElement = documented.get().getAnnotationType().asElement();
expect.that(MoreElements.isType(annotationElement)).isTrue();
- expect.that(MoreElements.asType(annotationElement).getQualifiedName().toString())
+ expect
+ .that(MoreElements.asType(annotationElement).getQualifiedName().toString())
.isEqualTo(Documented.class.getCanonicalName());
annotationElement = innerAnnotation.get().getAnnotationType().asElement();
expect.that(MoreElements.isType(annotationElement)).isTrue();
- expect.that(MoreElements.asType(annotationElement).getQualifiedName().toString())
+ expect
+ .that(MoreElements.asType(annotationElement).getQualifiedName().toString())
.isEqualTo(InnerAnnotation.class.getCanonicalName());
}
@@ -231,6 +287,7 @@
abstract String foo();
+ @SuppressWarnings("unused")
private void privateMethod() {}
}
@@ -259,7 +316,6 @@
@Test
public void getLocalAndInheritedMethods_Old() {
- Elements elements = compilation.getElements();
Types types = compilation.getTypes();
TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT);
TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG);
@@ -270,19 +326,20 @@
Set<ExecutableElement> objectMethods = visibleMethodsFromObject();
assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods);
Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods);
- assertThat(nonObjectMethods).containsExactly(
+ assertThat(nonObjectMethods)
+ .containsExactly(
getMethod(ParentInterface.class, "bar", longMirror),
getMethod(ParentClass.class, "foo"),
getMethod(Child.class, "bar"),
getMethod(Child.class, "baz"),
getMethod(Child.class, "buh", intMirror),
getMethod(Child.class, "buh", intMirror, intMirror))
- .inOrder();;
+ .inOrder();
+ ;
}
@Test
public void getLocalAndInheritedMethods() {
- Elements elements = compilation.getElements();
Types types = compilation.getTypes();
TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT);
TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG);
@@ -293,7 +350,8 @@
Set<ExecutableElement> objectMethods = visibleMethodsFromObject();
assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods);
Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods);
- assertThat(nonObjectMethods).containsExactly(
+ assertThat(nonObjectMethods)
+ .containsExactly(
getMethod(ParentInterface.class, "bar", longMirror),
getMethod(ParentClass.class, "foo"),
getMethod(Child.class, "bar"),
@@ -305,7 +363,6 @@
@Test
public void getAllMethods() {
- Elements elements = compilation.getElements();
Types types = compilation.getTypes();
TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT);
TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG);
@@ -316,7 +373,8 @@
Set<ExecutableElement> objectMethods = allMethodsFromObject();
assertThat(childTypeMethods).containsAtLeastElementsIn(objectMethods);
Set<ExecutableElement> nonObjectMethods = Sets.difference(childTypeMethods, objectMethods);
- assertThat(nonObjectMethods).containsExactly(
+ assertThat(nonObjectMethods)
+ .containsExactly(
getMethod(ParentInterface.class, "staticMethod"),
getMethod(ParentInterface.class, "bar", longMirror),
getMethod(ParentClass.class, "staticMethod"),
@@ -355,10 +413,9 @@
// Example from https://github.com/williamlian/daggerbug
@Test
public void getLocalAndInheritedMethods_DaggerBug() {
- Elements elementUtils = compilation.getElements();
- TypeElement main = elementUtils.getTypeElement(Main.ParentComponent.class.getCanonicalName());
- Set<ExecutableElement> methods = MoreElements.getLocalAndInheritedMethods(
- main, compilation.getTypes(), elementUtils);
+ TypeElement main = elements.getTypeElement(Main.ParentComponent.class.getCanonicalName());
+ Set<ExecutableElement> methods =
+ MoreElements.getLocalAndInheritedMethods(main, compilation.getTypes(), elements);
assertThat(methods).hasSize(1);
ExecutableElement method = methods.iterator().next();
assertThat(method.getSimpleName().toString()).isEqualTo("injectable");
@@ -404,7 +461,7 @@
}
private ExecutableElement getMethod(Class<?> c, String methodName, TypeMirror... parameterTypes) {
- TypeElement type = compilation.getElements().getTypeElement(c.getCanonicalName());
+ TypeElement type = elements.getTypeElement(c.getCanonicalName());
Types types = compilation.getTypes();
ExecutableElement found = null;
for (ExecutableElement method : ElementFilter.methodsIn(type.getEnclosedElements())) {
@@ -423,7 +480,7 @@
}
}
assertWithMessage(methodName + Arrays.toString(parameterTypes)).that(found).isNotNull();
- return found;
+ return requireNonNull(found);
}
private abstract static class AbstractAbstractList extends AbstractList<String> {}
@@ -458,8 +515,6 @@
// are implemented in AbstractList.
@Test
public void getLocalAndInheritedMethods_AbstractList() {
- Elements elements = compilation.getElements();
-
TypeElement abstractType =
elements.getTypeElement(AbstractAbstractList.class.getCanonicalName());
Set<ExecutableElement> abstractTypeMethods =
diff --git a/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java b/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java
index 05a0a11..7cd7865 100644
--- a/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java
+++ b/common/src/test/java/com/google/auto/common/MoreTypesIsTypeOfTest.java
@@ -43,13 +43,15 @@
private Elements elements;
- @Before public void setUp() {
+ @Before
+ public void setUp() {
this.elements = compilationRule.getElements();
}
private interface TestType {}
- @Test public void isTypeOf_DeclaredType() {
+ @Test
+ public void isTypeOf_declaredType() {
assertTrue(MoreTypes.isType(typeElementFor(TestType.class).asType()));
assertWithMessage("mirror represents the TestType")
.that(MoreTypes.isTypeOf(TestType.class, typeElementFor(TestType.class).asType()))
@@ -63,7 +65,8 @@
String[] array();
}
- @Test public void isTypeOf_ArrayType() {
+ @Test
+ public void isTypeOf_arrayType() {
assertTrue(MoreTypes.isType(typeElementFor(ArrayType.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(ArrayType.class));
assertWithMessage("array mirror represents an array Class object")
@@ -75,7 +78,8 @@
boolean method();
}
- @Test public void isTypeOf_PrimitiveBoolean() {
+ @Test
+ public void isTypeOf_primitiveBoolean() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveBoolean.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveBoolean.class));
assertWithMessage("mirror of a boolean").that(MoreTypes.isTypeOf(Boolean.TYPE, type)).isTrue();
@@ -85,7 +89,8 @@
byte method();
}
- @Test public void isTypeOf_PrimitiveByte() {
+ @Test
+ public void isTypeOf_primitiveByte() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveByte.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveByte.class));
assertWithMessage("mirror of a byte").that(MoreTypes.isTypeOf(Byte.TYPE, type)).isTrue();
@@ -95,7 +100,8 @@
char method();
}
- @Test public void isTypeOf_PrimitiveChar() {
+ @Test
+ public void isTypeOf_primitiveChar() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveChar.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveChar.class));
assertWithMessage("mirror of a char").that(MoreTypes.isTypeOf(Character.TYPE, type)).isTrue();
@@ -105,7 +111,8 @@
double method();
}
- @Test public void isTypeOf_PrimitiveDouble() {
+ @Test
+ public void isTypeOf_primitiveDouble() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveDouble.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveDouble.class));
assertWithMessage("mirror of a double").that(MoreTypes.isTypeOf(Double.TYPE, type)).isTrue();
@@ -115,7 +122,8 @@
float method();
}
- @Test public void isTypeOf_PrimitiveFloat() {
+ @Test
+ public void isTypeOf_primitiveFloat() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveFloat.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveFloat.class));
assertWithMessage("mirror of a float").that(MoreTypes.isTypeOf(Float.TYPE, type)).isTrue();
@@ -125,7 +133,8 @@
int method();
}
- @Test public void isTypeOf_PrimitiveInt() {
+ @Test
+ public void isTypeOf_primitiveInt() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveInt.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveInt.class));
assertWithMessage("mirror of a int").that(MoreTypes.isTypeOf(Integer.TYPE, type)).isTrue();
@@ -135,7 +144,8 @@
long method();
}
- @Test public void isTypeOf_PrimitiveLong() {
+ @Test
+ public void isTypeOf_primitiveLong() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveLong.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveLong.class));
assertWithMessage("mirror of a long").that(MoreTypes.isTypeOf(Long.TYPE, type)).isTrue();
@@ -145,7 +155,8 @@
short method();
}
- @Test public void isTypeOf_PrimitiveShort() {
+ @Test
+ public void isTypeOf_primitiveShort() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveShort.class).asType()));
TypeMirror type = extractReturnTypeFromHolder(typeElementFor(PrimitiveShort.class));
assertWithMessage("mirror of a short").that(MoreTypes.isTypeOf(Short.TYPE, type)).isTrue();
@@ -155,7 +166,8 @@
void method();
}
- @Test public void isTypeOf_void() {
+ @Test
+ public void isTypeOf_primitiveVoid() {
assertTrue(MoreTypes.isType(typeElementFor(PrimitiveVoid.class).asType()));
TypeMirror primitive = extractReturnTypeFromHolder(typeElementFor(PrimitiveVoid.class));
assertWithMessage("mirror of a void").that(MoreTypes.isTypeOf(Void.TYPE, primitive)).isTrue();
@@ -165,21 +177,25 @@
Void method();
}
- @Test public void isTypeOf_Void() {
+ @Test
+ public void isTypeOf_declaredVoid() {
assertTrue(MoreTypes.isType(typeElementFor(DeclaredVoid.class).asType()));
TypeMirror declared = extractReturnTypeFromHolder(typeElementFor(DeclaredVoid.class));
assertWithMessage("mirror of a void").that(MoreTypes.isTypeOf(Void.class, declared)).isTrue();
}
- @Test public void isTypeOf_fail() {
- assertFalse(MoreTypes.isType(
- getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType()));
+ @Test
+ public void isTypeOf_fail() {
+ assertFalse(
+ MoreTypes.isType(
+ getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType()));
TypeMirror method =
getOnlyElement(typeElementFor(DeclaredVoid.class).getEnclosedElements()).asType();
try {
MoreTypes.isTypeOf(String.class, method);
fail();
- } catch (IllegalArgumentException expected) {}
+ } catch (IllegalArgumentException expected) {
+ }
}
// Utility methods for this test.
diff --git a/common/src/test/java/com/google/auto/common/MoreTypesTest.java b/common/src/test/java/com/google/auto/common/MoreTypesTest.java
index 3cd360d..b8e84e0 100644
--- a/common/src/test/java/com/google/auto/common/MoreTypesTest.java
+++ b/common/src/test/java/com/google/auto/common/MoreTypesTest.java
@@ -16,11 +16,12 @@
package com.google.auto.common;
import static com.google.common.truth.Truth.assertThat;
+import static java.util.Objects.requireNonNull;
import static javax.lang.model.type.TypeKind.NONE;
import static javax.lang.model.type.TypeKind.VOID;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail;
-import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
@@ -49,6 +50,7 @@
import javax.lang.model.util.ElementFilter;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
+import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -90,48 +92,51 @@
DeclaredType containerOfString = types.getDeclaredType(container, stringType);
TypeMirror containedInObject = types.asMemberOf(containerOfObject, contained);
TypeMirror containedInString = types.asMemberOf(containerOfString, contained);
- EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
- .addEquivalenceGroup(types.getNullType())
- .addEquivalenceGroup(types.getNoType(NONE))
- .addEquivalenceGroup(types.getNoType(VOID))
- .addEquivalenceGroup(objectType)
- .addEquivalenceGroup(stringType)
- .addEquivalenceGroup(containedInObject)
- .addEquivalenceGroup(containedInString)
- .addEquivalenceGroup(funkyBounds.asType())
- .addEquivalenceGroup(funkyBounds2.asType())
- .addEquivalenceGroup(funkierBounds.asType())
- .addEquivalenceGroup(funkyBoundsVar, funkyBounds2Var)
- .addEquivalenceGroup(funkierBoundsVar)
- // Enum<E extends Enum<E>>
- .addEquivalenceGroup(enumElement.asType())
- // Map<K, V>
- .addEquivalenceGroup(mapType)
- .addEquivalenceGroup(mapOfObjectToObjectType)
- // Map<?, ?>
- .addEquivalenceGroup(types.getDeclaredType(mapElement, wildcard, wildcard))
- // Map
- .addEquivalenceGroup(types.erasure(mapType), types.erasure(mapOfObjectToObjectType))
- .addEquivalenceGroup(types.getDeclaredType(mapElement, objectType, stringType))
- .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, objectType))
- .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, stringType))
- .addEquivalenceGroup(setOfSetOfObject)
- .addEquivalenceGroup(setOfSetOfString)
- .addEquivalenceGroup(setOfSetOfSetOfObject)
- .addEquivalenceGroup(setOfSetOfSetOfString)
- .addEquivalenceGroup(wildcard)
- // ? extends Object
- .addEquivalenceGroup(types.getWildcardType(objectType, null))
- // ? extends String
- .addEquivalenceGroup(types.getWildcardType(stringType, null))
- // ? super String
- .addEquivalenceGroup(types.getWildcardType(null, stringType))
- // Map<String, Map<String, Set<Object>>>
- .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType,
- types.getDeclaredType(mapElement, stringType,
- types.getDeclaredType(setElement, objectType))))
- .addEquivalenceGroup(FAKE_ERROR_TYPE)
- ;
+ EquivalenceTester<TypeMirror> tester =
+ EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
+ .addEquivalenceGroup(types.getNullType())
+ .addEquivalenceGroup(types.getNoType(NONE))
+ .addEquivalenceGroup(types.getNoType(VOID))
+ .addEquivalenceGroup(objectType)
+ .addEquivalenceGroup(stringType)
+ .addEquivalenceGroup(containedInObject)
+ .addEquivalenceGroup(containedInString)
+ .addEquivalenceGroup(funkyBounds.asType())
+ .addEquivalenceGroup(funkyBounds2.asType())
+ .addEquivalenceGroup(funkierBounds.asType())
+ .addEquivalenceGroup(funkyBoundsVar, funkyBounds2Var)
+ .addEquivalenceGroup(funkierBoundsVar)
+ // Enum<E extends Enum<E>>
+ .addEquivalenceGroup(enumElement.asType())
+ // Map<K, V>
+ .addEquivalenceGroup(mapType)
+ .addEquivalenceGroup(mapOfObjectToObjectType)
+ // Map<?, ?>
+ .addEquivalenceGroup(types.getDeclaredType(mapElement, wildcard, wildcard))
+ // Map
+ .addEquivalenceGroup(types.erasure(mapType), types.erasure(mapOfObjectToObjectType))
+ .addEquivalenceGroup(types.getDeclaredType(mapElement, objectType, stringType))
+ .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, objectType))
+ .addEquivalenceGroup(types.getDeclaredType(mapElement, stringType, stringType))
+ .addEquivalenceGroup(setOfSetOfObject)
+ .addEquivalenceGroup(setOfSetOfString)
+ .addEquivalenceGroup(setOfSetOfSetOfObject)
+ .addEquivalenceGroup(setOfSetOfSetOfString)
+ .addEquivalenceGroup(wildcard)
+ // ? extends Object
+ .addEquivalenceGroup(types.getWildcardType(objectType, null))
+ // ? extends String
+ .addEquivalenceGroup(types.getWildcardType(stringType, null))
+ // ? super String
+ .addEquivalenceGroup(types.getWildcardType(null, stringType))
+ // Map<String, Map<String, Set<Object>>>
+ .addEquivalenceGroup(
+ types.getDeclaredType(
+ mapElement,
+ stringType,
+ types.getDeclaredType(
+ mapElement, stringType, types.getDeclaredType(setElement, objectType))))
+ .addEquivalenceGroup(FAKE_ERROR_TYPE);
for (TypeKind kind : TypeKind.values()) {
if (kind.isPrimitive()) {
@@ -144,20 +149,18 @@
}
}
- ImmutableSet<Class<?>> testClasses = ImmutableSet.of(
- ExecutableElementsGroupA.class,
- ExecutableElementsGroupB.class,
- ExecutableElementsGroupC.class,
- ExecutableElementsGroupD.class,
- ExecutableElementsGroupE.class);
+ ImmutableSet<Class<?>> testClasses =
+ ImmutableSet.of(
+ ExecutableElementsGroupA.class,
+ ExecutableElementsGroupB.class,
+ ExecutableElementsGroupC.class,
+ ExecutableElementsGroupD.class,
+ ExecutableElementsGroupE.class);
for (Class<?> testClass : testClasses) {
- ImmutableList<TypeMirror> equivalenceGroup = FluentIterable.from(
- elements.getTypeElement(testClass.getCanonicalName()).getEnclosedElements())
- .transform(new Function<Element, TypeMirror>() {
- @Override public TypeMirror apply(Element input) {
- return input.asType();
- }
- })
+ ImmutableList<TypeMirror> equivalenceGroup =
+ FluentIterable.from(
+ elements.getTypeElement(testClass.getCanonicalName()).getEnclosedElements())
+ .transform(Element::asType)
.toList();
tester.addEquivalenceGroup(equivalenceGroup);
}
@@ -168,35 +171,45 @@
@SuppressWarnings("unused")
private static final class ExecutableElementsGroupA {
ExecutableElementsGroupA() {}
+
void a() {}
+
public static void b() {}
}
@SuppressWarnings("unused")
private static final class ExecutableElementsGroupB {
ExecutableElementsGroupB(String s) {}
+
void a(String s) {}
+
public static void b(String s) {}
}
@SuppressWarnings("unused")
private static final class ExecutableElementsGroupC {
ExecutableElementsGroupC() throws Exception {}
+
void a() throws Exception {}
+
public static void b() throws Exception {}
}
@SuppressWarnings("unused")
private static final class ExecutableElementsGroupD {
ExecutableElementsGroupD() throws RuntimeException {}
+
void a() throws RuntimeException {}
+
public static void b() throws RuntimeException {}
}
@SuppressWarnings("unused")
private static final class ExecutableElementsGroupE {
<T> ExecutableElementsGroupE() {}
+
<T> void a() {}
+
public static <T> void b() {}
}
@@ -214,53 +227,44 @@
@SuppressWarnings("unused")
private static final class FunkierBounds<T extends Number & Comparable<T> & Cloneable> {}
- @Test public void testReferencedTypes() {
+ @Test
+ public void testReferencedTypes() {
Elements elements = compilationRule.getElements();
- TypeElement testDataElement = elements
- .getTypeElement(ReferencedTypesTestData.class.getCanonicalName());
+ TypeElement testDataElement =
+ elements.getTypeElement(ReferencedTypesTestData.class.getCanonicalName());
ImmutableMap<String, VariableElement> fieldIndex =
FluentIterable.from(ElementFilter.fieldsIn(testDataElement.getEnclosedElements()))
- .uniqueIndex(new Function<VariableElement, String>() {
- @Override public String apply(VariableElement input) {
- return input.getSimpleName().toString();
- }
- });
+ .uniqueIndex(input -> input.getSimpleName().toString());
- TypeElement objectElement =
- elements.getTypeElement(Object.class.getCanonicalName());
- TypeElement stringElement =
- elements.getTypeElement(String.class.getCanonicalName());
- TypeElement integerElement =
- elements.getTypeElement(Integer.class.getCanonicalName());
- TypeElement setElement =
- elements.getTypeElement(Set.class.getCanonicalName());
- TypeElement mapElement =
- elements.getTypeElement(Map.class.getCanonicalName());
+ TypeElement objectElement = elements.getTypeElement(Object.class.getCanonicalName());
+ TypeElement stringElement = elements.getTypeElement(String.class.getCanonicalName());
+ TypeElement integerElement = elements.getTypeElement(Integer.class.getCanonicalName());
+ TypeElement setElement = elements.getTypeElement(Set.class.getCanonicalName());
+ TypeElement mapElement = elements.getTypeElement(Map.class.getCanonicalName());
TypeElement charSequenceElement =
elements.getTypeElement(CharSequence.class.getCanonicalName());
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f1").asType()))
- .containsExactly(objectElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f2").asType()))
- .containsExactly(setElement, stringElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f3").asType()))
+ assertThat(referencedTypes(fieldIndex, "f1")).containsExactly(objectElement);
+ assertThat(referencedTypes(fieldIndex, "f2")).containsExactly(setElement, stringElement);
+ assertThat(referencedTypes(fieldIndex, "f3"))
.containsExactly(mapElement, stringElement, objectElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f4").asType()))
- .containsExactly(integerElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f5").asType()))
- .containsExactly(setElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f6").asType()))
- .containsExactly(setElement, charSequenceElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f7").asType()))
+ assertThat(referencedTypes(fieldIndex, "f4")).containsExactly(integerElement);
+ assertThat(referencedTypes(fieldIndex, "f5")).containsExactly(setElement);
+ assertThat(referencedTypes(fieldIndex, "f6")).containsExactly(setElement, charSequenceElement);
+ assertThat(referencedTypes(fieldIndex, "f7"))
.containsExactly(mapElement, stringElement, setElement, charSequenceElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f8").asType()))
- .containsExactly(stringElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f9").asType()))
- .containsExactly(stringElement);
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f10").asType())).isEmpty();
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f11").asType())).isEmpty();
- assertThat(MoreTypes.referencedTypes(fieldIndex.get("f12").asType()))
- .containsExactly(setElement, stringElement);
+ assertThat(referencedTypes(fieldIndex, "f8")).containsExactly(stringElement);
+ assertThat(referencedTypes(fieldIndex, "f9")).containsExactly(stringElement);
+ assertThat(referencedTypes(fieldIndex, "f10")).isEmpty();
+ assertThat(referencedTypes(fieldIndex, "f11")).isEmpty();
+ assertThat(referencedTypes(fieldIndex, "f12")).containsExactly(setElement, stringElement);
+ }
+
+ private static ImmutableSet<TypeElement> referencedTypes(
+ ImmutableMap<String, VariableElement> fieldIndex, String fieldName) {
+ VariableElement field = fieldIndex.get(fieldName);
+ requireNonNull(field, fieldName);
+ return MoreTypes.referencedTypes(field.asType());
}
@SuppressWarnings("unused") // types used in compiler tests
@@ -280,20 +284,23 @@
}
private static class Parent<T> {}
+
private static class ChildA extends Parent<Number> {}
+
private static class ChildB extends Parent<String> {}
+
private static class GenericChild<T> extends Parent<T> {}
+
private interface InterfaceType {}
@Test
public void asElement_throws() {
- TypeMirror javaDotLang =
- compilationRule.getElements().getPackageElement("java.lang").asType();
+ TypeMirror javaDotLang = compilationRule.getElements().getPackageElement("java.lang").asType();
try {
MoreTypes.asElement(javaDotLang);
fail();
- } catch (IllegalArgumentException expected) {}
-
+ } catch (IllegalArgumentException expected) {
+ }
}
@Test
@@ -301,8 +308,9 @@
Elements elements = compilationRule.getElements();
TypeElement stringElement = elements.getTypeElement("java.lang.String");
assertThat(MoreTypes.asElement(stringElement.asType())).isEqualTo(stringElement);
- TypeParameterElement setParameterElement = Iterables.getOnlyElement(
- compilationRule.getElements().getTypeElement("java.util.Set").getTypeParameters());
+ TypeParameterElement setParameterElement =
+ Iterables.getOnlyElement(
+ compilationRule.getElements().getTypeElement("java.util.Set").getTypeParameters());
assertThat(MoreTypes.asElement(setParameterElement.asType())).isEqualTo(setParameterElement);
// we don't test error types because those are very hard to get predictably
}
@@ -320,8 +328,7 @@
TypeElement genericChild = elements.getTypeElement(GenericChild.class.getCanonicalName());
TypeMirror genericChildOfNumber = types.getDeclaredType(genericChild, numberType);
TypeMirror genericChildOfInteger = types.getDeclaredType(genericChild, integerType);
- TypeMirror objectType =
- elements.getTypeElement(Object.class.getCanonicalName()).asType();
+ TypeMirror objectType = elements.getTypeElement(Object.class.getCanonicalName()).asType();
TypeMirror interfaceType =
elements.getTypeElement(InterfaceType.class.getCanonicalName()).asType();
@@ -343,18 +350,20 @@
Optional<DeclaredType> parentOfGenericChildOfInteger =
MoreTypes.nonObjectSuperclass(types, elements, (DeclaredType) genericChildOfInteger);
- EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
- .addEquivalenceGroup(parentOfChildA.get(),
- types.getDeclaredType(parent, numberType),
- parentOfGenericChildOfNumber.get())
- .addEquivalenceGroup(parentOfChildB.get(), types.getDeclaredType(parent, stringType))
- .addEquivalenceGroup(parentOfGenericChild.get(), parent.asType())
- .addEquivalenceGroup(parentOfGenericChildOfInteger.get(),
- types.getDeclaredType(parent, integerType));
+ EquivalenceTester<TypeMirror> tester =
+ EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
+ .addEquivalenceGroup(
+ parentOfChildA.get(),
+ types.getDeclaredType(parent, numberType),
+ parentOfGenericChildOfNumber.get())
+ .addEquivalenceGroup(parentOfChildB.get(), types.getDeclaredType(parent, stringType))
+ .addEquivalenceGroup(parentOfGenericChild.get(), parent.asType())
+ .addEquivalenceGroup(
+ parentOfGenericChildOfInteger.get(), types.getDeclaredType(parent, integerType));
tester.test();
}
-
+
@Test
public void testAsMemberOf_variableElement() {
Types types = compilationRule.getTypes();
@@ -364,11 +373,13 @@
TypeMirror integerType = elements.getTypeElement(Integer.class.getCanonicalName()).asType();
TypeElement paramsElement = elements.getTypeElement(Params.class.getCanonicalName());
- VariableElement tParam = Iterables.getOnlyElement(Iterables.getOnlyElement(
- ElementFilter.methodsIn(paramsElement.getEnclosedElements())).getParameters());
+ VariableElement tParam =
+ Iterables.getOnlyElement(
+ Iterables.getOnlyElement(ElementFilter.methodsIn(paramsElement.getEnclosedElements()))
+ .getParameters());
VariableElement tField =
- Iterables.getOnlyElement(ElementFilter.fieldsIn(paramsElement.getEnclosedElements()));
-
+ Iterables.getOnlyElement(ElementFilter.fieldsIn(paramsElement.getEnclosedElements()));
+
DeclaredType numberParams =
(DeclaredType) elements.getTypeElement(NumberParams.class.getCanonicalName()).asType();
DeclaredType stringParams =
@@ -376,7 +387,7 @@
TypeElement genericParams = elements.getTypeElement(GenericParams.class.getCanonicalName());
DeclaredType genericParamsOfNumber = types.getDeclaredType(genericParams, numberType);
DeclaredType genericParamsOfInteger = types.getDeclaredType(genericParams, integerType);
-
+
TypeMirror fieldOfNumberParams = MoreTypes.asMemberOf(types, numberParams, tField);
TypeMirror paramOfNumberParams = MoreTypes.asMemberOf(types, numberParams, tParam);
TypeMirror fieldOfStringParams = MoreTypes.asMemberOf(types, stringParams, tField);
@@ -388,62 +399,76 @@
TypeMirror paramOfGenericOfInteger =
MoreTypes.asMemberOf(types, genericParamsOfInteger, tParam);
- EquivalenceTester<TypeMirror> tester = EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
- .addEquivalenceGroup(fieldOfNumberParams, paramOfNumberParams, fieldOfGenericOfNumber,
- paramOfGenericOfNumber, numberType)
- .addEquivalenceGroup(fieldOfStringParams, paramOfStringParams, stringType)
- .addEquivalenceGroup(fieldOfGenericOfInteger, paramOfGenericOfInteger, integerType);
+ EquivalenceTester<TypeMirror> tester =
+ EquivalenceTester.<TypeMirror>of(MoreTypes.equivalence())
+ .addEquivalenceGroup(
+ fieldOfNumberParams,
+ paramOfNumberParams,
+ fieldOfGenericOfNumber,
+ paramOfGenericOfNumber,
+ numberType)
+ .addEquivalenceGroup(fieldOfStringParams, paramOfStringParams, stringType)
+ .addEquivalenceGroup(fieldOfGenericOfInteger, paramOfGenericOfInteger, integerType);
tester.test();
}
-
+
private static class Params<T> {
- @SuppressWarnings("unused") T t;
- @SuppressWarnings("unused") void add(T t) {}
+ @SuppressWarnings("unused")
+ T t;
+
+ @SuppressWarnings("unused")
+ void add(T t) {}
}
+
private static class NumberParams extends Params<Number> {}
+
private static class StringParams extends Params<String> {}
+
private static class GenericParams<T> extends Params<T> {}
- private static final ErrorType FAKE_ERROR_TYPE = new ErrorType() {
- @Override
- public TypeKind getKind() {
- return TypeKind.ERROR;
- }
+ private static final ErrorType FAKE_ERROR_TYPE =
+ new ErrorType() {
+ @Override
+ public TypeKind getKind() {
+ return TypeKind.ERROR;
+ }
- @Override
- public <R, P> R accept(TypeVisitor<R, P> v, P p) {
- return v.visitError(this, p);
- }
+ @Override
+ public <R, P> R accept(TypeVisitor<R, P> v, P p) {
+ return v.visitError(this, p);
+ }
- @Override
- public List<? extends TypeMirror> getTypeArguments() {
- return ImmutableList.of();
- }
+ @Override
+ public ImmutableList<? extends TypeMirror> getTypeArguments() {
+ return ImmutableList.of();
+ }
- @Override
- public TypeMirror getEnclosingType() {
- return null;
- }
+ @Override
+ public @Nullable TypeMirror getEnclosingType() {
+ return null;
+ }
- @Override
- public Element asElement() {
- return null;
- }
+ @Override
+ public @Nullable Element asElement() {
+ return null;
+ }
- // JDK8 Compatibility:
+ @Override
+ public <A extends Annotation> A @Nullable [] getAnnotationsByType(Class<A> annotationType) {
+ return null;
+ }
- public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
- return null;
- }
+ @Override
+ public <A extends Annotation> @Nullable A getAnnotation(Class<A> annotationType) {
+ return null;
+ }
- public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
- return null;
- }
-
- public List<? extends AnnotationMirror> getAnnotationMirrors() {
- return null;
- }
- };
+ @Override
+ @SuppressWarnings("MutableMethodReturnType")
+ public List<? extends AnnotationMirror> getAnnotationMirrors() {
+ return ImmutableList.of();
+ }
+ };
@Test
public void testIsConversionFromObjectUnchecked_yes() {
@@ -471,6 +496,21 @@
}
}
+ @Test
+ public void testIsTypeOf() {
+ Types types = compilationRule.getTypes();
+ PrimitiveType intType = types.getPrimitiveType(TypeKind.INT);
+ TypeMirror integerType = types.boxedClass(intType).asType();
+ WildcardType wildcardType = types.getWildcardType(null, null);
+ expect.that(MoreTypes.isTypeOf(int.class, intType)).isTrue();
+ expect.that(MoreTypes.isTypeOf(Integer.class, integerType)).isTrue();
+ expect.that(MoreTypes.isTypeOf(Integer.class, intType)).isFalse();
+ expect.that(MoreTypes.isTypeOf(int.class, integerType)).isFalse();
+ expect.that(MoreTypes.isTypeOf(Integer.class, FAKE_ERROR_TYPE)).isFalse();
+ assertThrows(
+ IllegalArgumentException.class, () -> MoreTypes.isTypeOf(Integer.class, wildcardType));
+ }
+
// The type of every field here is such that casting to it provokes an "unchecked" warning.
@SuppressWarnings("unused")
private static class Unchecked<T> {
diff --git a/common/src/test/java/com/google/auto/common/OverridesTest.java b/common/src/test/java/com/google/auto/common/OverridesTest.java
index afb7976..c5ccc5f 100644
--- a/common/src/test/java/com/google/auto/common/OverridesTest.java
+++ b/common/src/test/java/com/google/auto/common/OverridesTest.java
@@ -17,6 +17,7 @@
import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Objects.requireNonNull;
import static javax.lang.model.util.ElementFilter.methodsIn;
import com.google.common.base.Converter;
@@ -57,6 +58,7 @@
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import org.eclipse.jdt.internal.compiler.tool.EclipseCompiler;
+import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -103,6 +105,7 @@
abstract void initUtils(OverridesTest test);
}
+
private final CompilerType compilerType;
private Types typeUtils;
@@ -126,12 +129,15 @@
static class TypesForInheritance {
interface One {
void m();
+
void m(String x);
+
void n();
}
interface Two {
void m();
+
void m(int x);
}
@@ -142,28 +148,50 @@
static class ChildOfParent extends Parent {}
static class ChildOfOne implements One {
- @Override public void m() {}
- @Override public void m(String x) {}
- @Override public void n() {}
+ @Override
+ public void m() {}
+
+ @Override
+ public void m(String x) {}
+
+ @Override
+ public void n() {}
}
static class ChildOfOneAndTwo implements One, Two {
- @Override public void m() {}
- @Override public void m(String x) {}
- @Override public void m(int x) {}
- @Override public void n() {}
+ @Override
+ public void m() {}
+
+ @Override
+ public void m(String x) {}
+
+ @Override
+ public void m(int x) {}
+
+ @Override
+ public void n() {}
}
static class ChildOfParentAndOne extends Parent implements One {
- @Override public void m() {}
- @Override public void m(String x) {}
- @Override public void n() {}
+ @Override
+ public void m() {}
+
+ @Override
+ public void m(String x) {}
+
+ @Override
+ public void n() {}
}
static class ChildOfParentAndOneAndTwo extends Parent implements One, Two {
- @Override public void m(String x) {}
- @Override public void m(int x) {}
- @Override public void n() {}
+ @Override
+ public void m(String x) {}
+
+ @Override
+ public void m(int x) {}
+
+ @Override
+ public void n() {}
}
abstract static class AbstractChildOfOne implements One {}
@@ -194,14 +222,20 @@
abstract static class BindingDeclaration implements HasKey {
abstract Optional<Element> bindingElement();
+
abstract Optional<TypeElement> contributingModule();
}
- abstract static class MultibindingDeclaration
- extends BindingDeclaration implements HasBindingType, HasContributionType {
- @Override public abstract Key key();
- @Override public abstract ContributionType contributionType();
- @Override public abstract BindingType bindingType();
+ abstract static class MultibindingDeclaration extends BindingDeclaration
+ implements HasBindingType, HasContributionType {
+ @Override
+ public abstract Key key();
+
+ @Override
+ public abstract ContributionType contributionType();
+
+ @Override
+ public abstract BindingType bindingType();
}
}
@@ -221,16 +255,26 @@
}
static class TypesForGenerics {
- interface XCollection<E> {
+ interface GCollection<E> {
boolean add(E x);
}
- interface XList<E> extends XCollection<E> {
- @Override public boolean add(E x);
+ interface GList<E> extends GCollection<E> {
+ @Override
+ boolean add(E x);
}
- static class StringList implements XList<String> {
- @Override public boolean add(String x) {
+ static class StringList implements GList<String> {
+ @Override
+ public boolean add(String x) {
+ return false;
+ }
+ }
+
+ @SuppressWarnings("rawtypes")
+ static class RawList implements GList {
+ @Override
+ public boolean add(Object x) {
return false;
}
}
@@ -243,7 +287,8 @@
}
static class RawChildOfRaw extends RawParent {
- @Override void frob(List x) {}
+ @Override
+ void frob(List x) {}
}
static class NonRawParent {
@@ -251,7 +296,8 @@
}
static class RawChildOfNonRaw extends NonRawParent {
- @Override void frob(List x) {}
+ @Override
+ void frob(List x) {}
}
}
@@ -291,8 +337,9 @@
// since the two Es are not the same.
@Test
public void overridesDiamond() {
- checkOverridesInSet(ImmutableSet.<Class<?>>of(
- Collection.class, List.class, AbstractCollection.class, AbstractList.class));
+ checkOverridesInSet(
+ ImmutableSet.<Class<?>>of(
+ Collection.class, List.class, AbstractCollection.class, AbstractList.class));
}
private void checkOverridesInContainedClasses(Class<?> container) {
@@ -324,10 +371,13 @@
expect
.withMessage(
"%s.%s overrides %s.%s in %s: javac says %s, we say %s",
- overrider.getEnclosingElement(), overrider,
- overridden.getEnclosingElement(), overridden,
+ overrider.getEnclosingElement(),
+ overrider,
+ overridden.getEnclosingElement(),
+ overridden,
in,
- javacSays, weSay)
+ javacSays,
+ weSay)
.fail();
}
}
@@ -355,7 +405,7 @@
}
}
assertThat(found).isNotNull();
- return found;
+ return requireNonNull(found);
}
// These skeletal parallels to the real collection classes ensure that the test is independent
@@ -375,8 +425,8 @@
}
}
- private abstract static class XAbstractList<E>
- extends XAbstractCollection<E> implements XList<E> {
+ private abstract static class XAbstractList<E> extends XAbstractCollection<E>
+ implements XList<E> {
@Override
public boolean add(E e) {
return true;
@@ -440,7 +490,7 @@
extends Converter<String, Range<T>> {
@Override
protected String doBackward(Range<T> b) {
- return null;
+ return "";
}
}
@@ -470,9 +520,8 @@
explicitOverrides.methodFromSuperclasses(xAbstractStringList, add);
assertThat(addInAbstractStringList).isNull();
- ExecutableElement addInStringList =
- explicitOverrides.methodFromSuperclasses(xStringList, add);
- assertThat(addInStringList.getEnclosingElement()).isEqualTo(xAbstractList);
+ ExecutableElement addInStringList = explicitOverrides.methodFromSuperclasses(xStringList, add);
+ assertThat(requireNonNull(addInStringList).getEnclosingElement()).isEqualTo(xAbstractList);
}
@Test
@@ -487,20 +536,21 @@
ExecutableElement addInAbstractStringList =
explicitOverrides.methodFromSuperinterfaces(xAbstractStringList, add);
- assertThat(addInAbstractStringList.getEnclosingElement()).isEqualTo(xCollection);
+ assertThat(requireNonNull(addInAbstractStringList).getEnclosingElement())
+ .isEqualTo(xCollection);
ExecutableElement addInNumberList =
explicitOverrides.methodFromSuperinterfaces(xNumberList, add);
- assertThat(addInNumberList.getEnclosingElement()).isEqualTo(xAbstractList);
+ assertThat(requireNonNull(addInNumberList).getEnclosingElement()).isEqualTo(xAbstractList);
- ExecutableElement addInList =
- explicitOverrides.methodFromSuperinterfaces(xList, add);
- assertThat(addInList.getEnclosingElement()).isEqualTo(xCollection);
+ ExecutableElement addInList = explicitOverrides.methodFromSuperinterfaces(xList, add);
+ assertThat(requireNonNull(addInList).getEnclosingElement()).isEqualTo(xCollection);
}
- private void assertTypeListsEqual(List<TypeMirror> actual, List<TypeMirror> expected) {
- assertThat(actual.size()).isEqualTo(expected.size());
- for (int i = 0; i < actual.size(); i++) {
+ private void assertTypeListsEqual(@Nullable List<TypeMirror> actual, List<TypeMirror> expected) {
+ requireNonNull(actual);
+ assertThat(actual).hasSize(expected.size());
+ for (int i = 0; i < actual.size(); i++) {
assertThat(typeUtils.isSameType(actual.get(i), expected.get(i))).isTrue();
}
}
@@ -552,10 +602,11 @@
// it hard for ecj to find the boot class path. Elsewhere it is unnecessary but harmless.
File rtJar = new File(StandardSystemProperty.JAVA_HOME.value() + "/lib/rt.jar");
if (rtJar.exists()) {
- List<File> bootClassPath = ImmutableList.<File>builder()
- .add(rtJar)
- .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH))
- .build();
+ List<File> bootClassPath =
+ ImmutableList.<File>builder()
+ .add(rtJar)
+ .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH))
+ .build();
fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
}
Iterable<? extends JavaFileObject> sources = fileManager.getJavaFileObjects(dummySourceFile);
@@ -583,8 +634,7 @@
}
@Override
- public boolean process(
- Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
ecjCompilation.elements = processingEnv.getElementUtils();
ecjCompilation.types = processingEnv.getTypeUtils();
@@ -643,24 +693,24 @@
private static final TypeVisitor<String, Void> ERASED_STRING_TYPE_VISITOR =
new SimpleTypeVisitor6<String, Void>() {
- @Override
- protected String defaultAction(TypeMirror e, Void p) {
- return e.toString();
- }
+ @Override
+ protected String defaultAction(TypeMirror e, Void p) {
+ return e.toString();
+ }
- @Override
- public String visitArray(ArrayType t, Void p) {
- return visit(t.getComponentType()) + "[]";
- }
+ @Override
+ public String visitArray(ArrayType t, Void p) {
+ return visit(t.getComponentType()) + "[]";
+ }
- @Override
- public String visitDeclared(DeclaredType t, Void p) {
- return MoreElements.asType(t.asElement()).getQualifiedName().toString();
- }
+ @Override
+ public String visitDeclared(DeclaredType t, Void p) {
+ return MoreElements.asType(t.asElement()).getQualifiedName().toString();
+ }
- @Override
- public String visitTypeVariable(TypeVariable t, Void p) {
- return visit(t.getUpperBound());
- }
- };
+ @Override
+ public String visitTypeVariable(TypeVariable t, Void p) {
+ return visit(t.getUpperBound());
+ }
+ };
}
diff --git a/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java b/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java
index d73e1b6..0bad83d 100644
--- a/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java
+++ b/common/src/test/java/com/google/auto/common/SimpleAnnotationMirrorTest.java
@@ -46,6 +46,7 @@
@interface MultipleValues {
int value1();
+
int value2();
}
diff --git a/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java b/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java
index 4fc61b5..ea85365 100644
--- a/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java
+++ b/common/src/test/java/com/google/auto/common/SimpleTypeAnnotationValueTest.java
@@ -28,6 +28,7 @@
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleAnnotationValueVisitor8;
import javax.lang.model.util.Types;
+import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@@ -70,18 +71,21 @@
@Test
public void visitorMethod() {
- SimpleTypeAnnotationValue.of(objectType).accept(new SimpleAnnotationValueVisitor8<Void, Void>(){
- @Override
- public Void visitType(TypeMirror typeMirror, Void aVoid) {
- // do nothing, expected case
- return null;
- }
+ SimpleTypeAnnotationValue.of(objectType)
+ .accept(
+ new SimpleAnnotationValueVisitor8<@Nullable Void, @Nullable Void>() {
+ @Override
+ public @Nullable Void visitType(TypeMirror typeMirror, @Nullable Void aVoid) {
+ // do nothing, expected case
+ return null;
+ }
- @Override
- protected Void defaultAction(Object o, Void aVoid) {
- throw new AssertionError();
- }
- }, null);
+ @Override
+ protected @Nullable Void defaultAction(Object o, @Nullable Void aVoid) {
+ throw new AssertionError();
+ }
+ },
+ null);
}
@Test
diff --git a/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java b/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java
index 15e54ff..c9bcf77 100644
--- a/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java
+++ b/common/src/test/java/com/google/auto/common/SuperficialValidationTest.java
@@ -35,231 +35,263 @@
public class SuperficialValidationTest {
@Test
public void missingReturnType() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "abstract class TestClass {",
- " abstract MissingType blah();",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "abstract class TestClass {",
+ " abstract MissingType blah();",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void missingGenericReturnType() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "abstract class TestClass {",
- " abstract MissingType<?> blah();",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "abstract class TestClass {",
+ " abstract MissingType<?> blah();",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void missingReturnTypeTypeParameter() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "import java.util.Map;",
- "import java.util.Set;",
- "",
- "abstract class TestClass {",
- " abstract Map<Set<?>, MissingType<?>> blah();",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "import java.util.Map;",
+ "import java.util.Set;",
+ "",
+ "abstract class TestClass {",
+ " abstract Map<Set<?>, MissingType<?>> blah();",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void missingTypeParameter() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "class TestClass<T extends MissingType> {}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass", //
+ "package test;",
+ "",
+ "class TestClass<T extends MissingType> {}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void missingParameterType() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "abstract class TestClass {",
- " abstract void foo(MissingType x);",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "abstract class TestClass {",
+ " abstract void foo(MissingType x);",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void missingAnnotation() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "@MissingAnnotation",
- "class TestClass {}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass", //
+ "package test;",
+ "",
+ "@MissingAnnotation",
+ "class TestClass {}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void handlesRecursiveTypeParams() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "class TestClass<T extends Comparable<T>> {}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass", //
+ "package test;",
+ "",
+ "class TestClass<T extends Comparable<T>> {}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
+ }
+ })
.compilesWithoutError();
}
@Test
public void handlesRecursiveType() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "abstract class TestClass {",
- " abstract TestClass foo(TestClass x);",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "abstract class TestClass {",
+ " abstract TestClass foo(TestClass x);",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isTrue();
+ }
+ })
.compilesWithoutError();
}
@Test
public void missingWildcardBound() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "import java.util.Set;",
- "",
- "class TestClass {",
- " Set<? extends MissingType> extendsTest() {",
- " return null;",
- " }",
- "",
- " Set<? super MissingType> superTest() {",
- " return null;",
- " }",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "import java.util.Set;",
+ "",
+ "class TestClass {",
+ " Set<? extends MissingType> extendsTest() {",
+ " return null;",
+ " }",
+ "",
+ " Set<? super MissingType> superTest() {",
+ " return null;",
+ " }",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void missingIntersection() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines(
- "test.TestClass",
- "package test;",
- "",
- "class TestClass<T extends Number & Missing> {}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.TestClass",
+ "package test;",
+ "",
+ "class TestClass<T extends Number & Missing> {}");
assertAbout(javaSource())
.that(javaFileObject)
- .processedWith(new AssertingProcessor() {
- @Override void runAssertions() {
- TypeElement testClassElement =
- processingEnv.getElementUtils().getTypeElement("test.TestClass");
- assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
- }
- })
+ .processedWith(
+ new AssertingProcessor() {
+ @Override
+ void runAssertions() {
+ TypeElement testClassElement =
+ processingEnv.getElementUtils().getTypeElement("test.TestClass");
+ assertThat(SuperficialValidation.validateElement(testClassElement)).isFalse();
+ }
+ })
.failsToCompile();
}
@Test
public void invalidAnnotationValue() {
- JavaFileObject javaFileObject = JavaFileObjects.forSourceLines("test.Outer",
- "package test;",
- "",
- "final class Outer {",
- " @interface TestAnnotation {",
- " Class[] classes();",
- " }",
- "",
- " @TestAnnotation(classes = Foo)",
- " static class TestClass {}",
- "}");
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "test.Outer",
+ "package test;",
+ "",
+ "final class Outer {",
+ " @interface TestAnnotation {",
+ " Class[] classes();",
+ " }",
+ "",
+ " @TestAnnotation(classes = Foo)",
+ " static class TestClass {}",
+ "}");
assertAbout(javaSource())
.that(javaFileObject)
.processedWith(
diff --git a/common/src/test/java/com/google/auto/common/VisibilityTest.java b/common/src/test/java/com/google/auto/common/VisibilityTest.java
index 6a80b7a..fc5e630 100644
--- a/common/src/test/java/com/google/auto/common/VisibilityTest.java
+++ b/common/src/test/java/com/google/auto/common/VisibilityTest.java
@@ -39,9 +39,10 @@
public void packageVisibility() {
assertThat(Visibility.ofElement(compilation.getElements().getPackageElement("java.lang")))
.isEqualTo(PUBLIC);
- assertThat(Visibility.ofElement(
- compilation.getElements().getPackageElement("com.google.auto.common")))
- .isEqualTo(PUBLIC);
+ assertThat(
+ Visibility.ofElement(
+ compilation.getElements().getPackageElement("com.google.auto.common")))
+ .isEqualTo(PUBLIC);
}
@Test
@@ -61,32 +62,44 @@
@SuppressWarnings("unused")
public static class PublicClass {
public static class NestedPublicClass {}
+
protected static class NestedProtectedClass {}
+
static class NestedDefaultClass {}
+
private static class NestedPrivateClass {}
}
@SuppressWarnings("unused")
protected static class ProtectedClass {
public static class NestedPublicClass {}
+
protected static class NestedProtectedClass {}
+
static class NestedDefaultClass {}
+
private static class NestedPrivateClass {}
}
@SuppressWarnings("unused")
static class DefaultClass {
public static class NestedPublicClass {}
+
protected static class NestedProtectedClass {}
+
static class NestedDefaultClass {}
+
private static class NestedPrivateClass {}
}
@SuppressWarnings("unused")
private static class PrivateClass {
public static class NestedPublicClass {}
+
protected static class NestedProtectedClass {}
+
static class NestedDefaultClass {}
+
private static class NestedPrivateClass {}
}
@@ -94,21 +107,25 @@
public void classVisibility() {
assertThat(Visibility.ofElement(compilation.getElements().getTypeElement("java.util.Map")))
.isEqualTo(PUBLIC);
- assertThat(Visibility.ofElement(
- compilation.getElements().getTypeElement("java.util.Map.Entry")))
- .isEqualTo(PUBLIC);
- assertThat(Visibility.ofElement(
- compilation.getElements().getTypeElement(PublicClass.class.getCanonicalName())))
- .isEqualTo(PUBLIC);
- assertThat(Visibility.ofElement(
- compilation.getElements().getTypeElement(ProtectedClass.class.getCanonicalName())))
- .isEqualTo(PROTECTED);
- assertThat(Visibility.ofElement(
- compilation.getElements().getTypeElement(DefaultClass.class.getCanonicalName())))
- .isEqualTo(DEFAULT);
- assertThat(Visibility.ofElement(
- compilation.getElements().getTypeElement(PrivateClass.class.getCanonicalName())))
- .isEqualTo(PRIVATE);
+ assertThat(
+ Visibility.ofElement(compilation.getElements().getTypeElement("java.util.Map.Entry")))
+ .isEqualTo(PUBLIC);
+ assertThat(
+ Visibility.ofElement(
+ compilation.getElements().getTypeElement(PublicClass.class.getCanonicalName())))
+ .isEqualTo(PUBLIC);
+ assertThat(
+ Visibility.ofElement(
+ compilation.getElements().getTypeElement(ProtectedClass.class.getCanonicalName())))
+ .isEqualTo(PROTECTED);
+ assertThat(
+ Visibility.ofElement(
+ compilation.getElements().getTypeElement(DefaultClass.class.getCanonicalName())))
+ .isEqualTo(DEFAULT);
+ assertThat(
+ Visibility.ofElement(
+ compilation.getElements().getTypeElement(PrivateClass.class.getCanonicalName())))
+ .isEqualTo(PRIVATE);
}
@Test
@@ -118,14 +135,11 @@
assertThat(effectiveVisiblityOfClass(DefaultClass.class)).isEqualTo(DEFAULT);
assertThat(effectiveVisiblityOfClass(PrivateClass.class)).isEqualTo(PRIVATE);
- assertThat(effectiveVisiblityOfClass(PublicClass.NestedPublicClass.class))
- .isEqualTo(PUBLIC);
+ assertThat(effectiveVisiblityOfClass(PublicClass.NestedPublicClass.class)).isEqualTo(PUBLIC);
assertThat(effectiveVisiblityOfClass(PublicClass.NestedProtectedClass.class))
.isEqualTo(PROTECTED);
- assertThat(effectiveVisiblityOfClass(PublicClass.NestedDefaultClass.class))
- .isEqualTo(DEFAULT);
- assertThat(effectiveVisiblityOfClass(PublicClass.NestedPrivateClass.class))
- .isEqualTo(PRIVATE);
+ assertThat(effectiveVisiblityOfClass(PublicClass.NestedDefaultClass.class)).isEqualTo(DEFAULT);
+ assertThat(effectiveVisiblityOfClass(PublicClass.NestedPrivateClass.class)).isEqualTo(PRIVATE);
assertThat(effectiveVisiblityOfClass(ProtectedClass.NestedPublicClass.class))
.isEqualTo(PROTECTED);
@@ -136,23 +150,17 @@
assertThat(effectiveVisiblityOfClass(ProtectedClass.NestedPrivateClass.class))
.isEqualTo(PRIVATE);
- assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPublicClass.class))
- .isEqualTo(DEFAULT);
+ assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPublicClass.class)).isEqualTo(DEFAULT);
assertThat(effectiveVisiblityOfClass(DefaultClass.NestedProtectedClass.class))
.isEqualTo(DEFAULT);
- assertThat(effectiveVisiblityOfClass(DefaultClass.NestedDefaultClass.class))
- .isEqualTo(DEFAULT);
- assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPrivateClass.class))
- .isEqualTo(PRIVATE);
+ assertThat(effectiveVisiblityOfClass(DefaultClass.NestedDefaultClass.class)).isEqualTo(DEFAULT);
+ assertThat(effectiveVisiblityOfClass(DefaultClass.NestedPrivateClass.class)).isEqualTo(PRIVATE);
- assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPublicClass.class))
- .isEqualTo(PRIVATE);
+ assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPublicClass.class)).isEqualTo(PRIVATE);
assertThat(effectiveVisiblityOfClass(PrivateClass.NestedProtectedClass.class))
.isEqualTo(PRIVATE);
- assertThat(effectiveVisiblityOfClass(PrivateClass.NestedDefaultClass.class))
- .isEqualTo(PRIVATE);
- assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPrivateClass.class))
- .isEqualTo(PRIVATE);
+ assertThat(effectiveVisiblityOfClass(PrivateClass.NestedDefaultClass.class)).isEqualTo(PRIVATE);
+ assertThat(effectiveVisiblityOfClass(PrivateClass.NestedPrivateClass.class)).isEqualTo(PRIVATE);
}
private Visibility effectiveVisiblityOfClass(Class<?> clazz) {
diff --git a/factory/pom.xml b/factory/pom.xml
index 48bcfef..629223a 100644
--- a/factory/pom.xml
+++ b/factory/pom.xml
@@ -36,9 +36,11 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ <auto-service.version>1.0</auto-service.version>
+ <auto-value.version>1.8.1</auto-value.version>
<java.version>1.8</java.version>
- <guava.version>28.2-jre</guava.version>
- <truth.version>1.0.1</truth.version>
+ <guava.version>30.1.1-jre</guava.version>
+ <truth.version>1.1.3</truth.version>
</properties>
<scm>
@@ -69,43 +71,25 @@
<dependency>
<groupId>com.google.auto</groupId>
<artifactId>auto-common</artifactId>
- <version>0.10</version>
+ <version>1.1</version>
</dependency>
<dependency>
<groupId>com.google.auto.value</groupId>
<artifactId>auto-value-annotations</artifactId>
- <version>1.7</version>
- </dependency>
- <dependency>
- <groupId>com.google.auto.value</groupId>
- <artifactId>auto-value</artifactId>
- <version>1.7</version>
- <scope>provided</scope>
+ <version>${auto-value.version}</version>
</dependency>
<dependency>
<groupId>com.google.auto.service</groupId>
- <artifactId>auto-service</artifactId>
- <version>1.0-rc6</version>
- <scope>provided</scope>
+ <artifactId>auto-service-annotations</artifactId>
+ <version>${auto-service.version}</version>
</dependency>
<dependency>
<groupId>net.ltgt.gradle.incap</groupId>
<artifactId>incap</artifactId>
- <version>0.2</version>
+ <version>0.3</version>
<scope>provided</scope>
</dependency>
<dependency>
- <groupId>net.ltgt.gradle.incap</groupId>
- <artifactId>incap-processor</artifactId>
- <version>0.2</version>
- <scope>provided</scope>
- </dependency>
- <dependency>
- <groupId>com.google.googlejavaformat</groupId>
- <artifactId>google-java-format</artifactId>
- <version>1.7</version>
- </dependency>
- <dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>${guava.version}</version>
@@ -113,7 +97,7 @@
<dependency>
<groupId>com.squareup</groupId>
<artifactId>javapoet</artifactId>
- <version>1.12.1</version>
+ <version>1.13.0</version>
</dependency>
<dependency>
<groupId>javax.inject</groupId>
@@ -124,13 +108,13 @@
<dependency>
<groupId>com.google.testing.compile</groupId>
<artifactId>compile-testing</artifactId>
- <version>0.18</version>
+ <version>0.19</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
- <version>4.13</version>
+ <version>4.13.2</version>
<scope>test</scope>
</dependency>
<dependency>
@@ -157,29 +141,54 @@
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
+ <annotationProcessorPaths>
+ <path>
+ <groupId>com.google.auto.service</groupId>
+ <artifactId>auto-service</artifactId>
+ <version>${auto-service.version}</version>
+ </path>
+ <path>
+ <groupId>com.google.auto.value</groupId>
+ <artifactId>auto-value</artifactId>
+ <version>${auto-value.version}</version>
+ </path>
+ <path>
+ <groupId>net.ltgt.gradle.incap</groupId>
+ <artifactId>incap-processor</artifactId>
+ <version>0.3</version>
+ </path>
+ </annotationProcessorPaths>
</configuration>
<dependencies>
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
</plugin>
<plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <version>2.22.2</version>
+ <configuration>
+ <argLine>${test.jvm.flags}</argLine>
+ </configuration>
+ </plugin>
+ <plugin>
<artifactId>maven-jar-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
</plugin>
<plugin>
<artifactId>maven-invoker-plugin</artifactId>
- <version>3.0.1</version>
+ <version>3.2.2</version>
<configuration>
<addTestClassPath>true</addTestClassPath>
<cloneProjectsTo>${project.build.directory}/it</cloneProjectsTo>
@@ -205,4 +214,15 @@
</plugin>
</plugins>
</build>
+ <profiles>
+ <profile>
+ <id>open-modules</id>
+ <activation>
+ <jdk>[9,)</jdk>
+ </activation>
+ <properties>
+ <test.jvm.flags>--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</test.jvm.flags>
+ </properties>
+ </profile>
+ </profiles>
</project>
diff --git a/factory/src/it/functional/pom.xml b/factory/src/it/functional/pom.xml
index 56e8f6f..a7a1853 100644
--- a/factory/src/it/functional/pom.xml
+++ b/factory/src/it/functional/pom.xml
@@ -45,7 +45,7 @@
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
- <version>27.0.1-jre</version>
+ <version>29.0-jre</version>
</dependency>
<dependency>
<groupId>com.google.inject</groupId>
@@ -66,7 +66,7 @@
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
- <version>4.12</version>
+ <version>4.13.2</version>
<scope>test</scope>
</dependency>
<dependency>
@@ -82,12 +82,12 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
@@ -99,7 +99,7 @@
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.5</version>
</dependency>
</dependencies>
</plugin>
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java
index 4c4a38a..f32e9f8 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/DaggerModule.java
@@ -16,44 +16,44 @@
package com.google.auto.factory;
import com.google.auto.factory.otherpackage.OtherPackage;
+import dagger.Binds;
import dagger.Module;
import dagger.Provides;
@Module
-final class DaggerModule {
- @Provides Dependency provideDependency(DependencyImpl impl) {
- return impl;
- }
+abstract class DaggerModule {
+ private DaggerModule() {} // no instances
- @Provides
+ @Binds
+ abstract Dependency provideDependency(DependencyImpl impl);
+
+ @Binds
@Qualifier
- Dependency provideQualifiedDependency(QualifiedDependencyImpl impl) {
- return impl;
- }
+ abstract Dependency provideQualifiedDependency(QualifiedDependencyImpl impl);
@Provides
- int providePrimitive() {
+ static int providePrimitive() {
return 1;
}
@Provides
@Qualifier
- int provideQualifiedPrimitive() {
+ static int provideQualifiedPrimitive() {
return 2;
}
@Provides
- Number provideNumber() {
+ static Number provideNumber() {
return 3;
}
@Provides
- ReferencePackage provideReferencePackage(ReferencePackageFactory factory) {
+ static ReferencePackage provideReferencePackage(ReferencePackageFactory factory) {
return factory.create(17);
}
@Provides
- OtherPackage provideOtherPackage() {
+ static OtherPackage provideOtherPackage() {
return new OtherPackage(null, 23);
}
}
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java
index 4c019ea..d94a3cf 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/DependencyImpl.java
@@ -18,5 +18,6 @@
import javax.inject.Inject;
public class DependencyImpl implements Dependency {
- @Inject DependencyImpl() {}
+ @Inject
+ DependencyImpl() {}
}
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java
index f7c13b4..31954a1 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/GenericFoo.java
@@ -28,10 +28,7 @@
private final E depE;
<D extends IntAccessor & StringAccessor> GenericFoo(
- @Provided Provider<A> depA,
- B depB,
- D depD,
- E depE) {
+ @Provided Provider<A> depA, B depB, D depD, E depE) {
this.depA = depA.get();
this.depB = depB;
this.depDIntAccessor = depD;
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java
index 45d4d26..7734665 100644
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/GuiceModule.java
@@ -18,7 +18,8 @@
import com.google.inject.AbstractModule;
public class GuiceModule extends AbstractModule {
- @Override protected void configure() {
+ @Override
+ protected void configure() {
bind(Dependency.class).to(DependencyImpl.class);
bind(Dependency.class).annotatedWith(Qualifier.class).to(QualifiedDependencyImpl.class);
bind(Integer.class).toInstance(1);
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java
old mode 100644
new mode 100755
index 22aff65..4f67c3b
--- a/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java
+++ b/factory/src/it/functional/src/main/java/com/google/auto/factory/ReferencePackage.java
@@ -25,9 +25,7 @@
private final int random;
@Inject
- public ReferencePackage(
- @Provided OtherPackageFactory otherPackageFactory,
- int random) {
+ ReferencePackage(@Provided OtherPackageFactory otherPackageFactory, int random) {
this.otherPackageFactory = otherPackageFactory;
this.random = random;
}
diff --git a/factory/src/it/functional/src/main/java/com/google/auto/factory/otherpackage/OtherPackage.java b/factory/src/it/functional/src/main/java/com/google/auto/factory/otherpackage/OtherPackage.java
old mode 100644
new mode 100755
diff --git a/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java b/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java
index e141211..3caa5a5 100644
--- a/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java
+++ b/factory/src/it/functional/src/test/java/com/google/auto/factory/DependencyInjectionIntegrationTest.java
@@ -19,7 +19,8 @@
private static final IntAndStringAccessor INT_AND_STRING_ACCESSOR = new IntAndStringAccessor() {};
- @Test public void daggerInjectedFactory() {
+ @Test
+ public void daggerInjectedFactory() {
FooFactory fooFactory = DaggerFactoryComponent.create().factory();
Foo one = fooFactory.create("A");
Foo two = fooFactory.create("B");
@@ -46,8 +47,9 @@
genericFooFactory.create(ImmutableList.of(3L), INT_AND_STRING_ACCESSOR, DepE.VALUE_1);
ArrayList<Double> intAndStringAccessorArrayList = new ArrayList<>();
intAndStringAccessorArrayList.add(4.0);
- GenericFoo<Number, ArrayList<Double>, Long, DepE> four = genericFooFactory.create(
- intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
+ GenericFoo<Number, ArrayList<Double>, Long, DepE> four =
+ genericFooFactory.create(
+ intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
assertThat(three.getDepA()).isEqualTo(3);
ImmutableList<Long> unusedLongList = three.getDepB();
assertThat(three.getDepB()).containsExactly(3L);
@@ -75,7 +77,8 @@
assertThat(otherPackage.random()).isEqualTo(5);
}
- @Test public void guiceInjectedFactory() {
+ @Test
+ public void guiceInjectedFactory() {
FooFactory fooFactory = Guice.createInjector(new GuiceModule()).getInstance(FooFactory.class);
Foo one = fooFactory.create("A");
Foo two = fooFactory.create("B");
@@ -103,8 +106,9 @@
genericFooFactory.create(ImmutableList.of(3L), INT_AND_STRING_ACCESSOR, DepE.VALUE_1);
ArrayList<Double> intAndStringAccessorArrayList = new ArrayList<>();
intAndStringAccessorArrayList.add(4.0);
- GenericFoo<Number, ArrayList<Double>, Long, DepE> four = genericFooFactory.create(
- intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
+ GenericFoo<Number, ArrayList<Double>, Long, DepE> four =
+ genericFooFactory.create(
+ intAndStringAccessorArrayList, INT_AND_STRING_ACCESSOR, DepE.VALUE_2);
assertThat(three.getDepA()).isEqualTo(3);
ImmutableList<Long> unusedLongList = three.getDepB();
assertThat(three.getDepB()).containsExactly(3L);
@@ -124,8 +128,7 @@
@Test
public void guiceInjectedPackageSpanningFactory() {
ReferencePackageFactory referencePackageFactory =
- Guice.createInjector(new GuiceModule())
- .getInstance(ReferencePackageFactory.class);
+ Guice.createInjector(new GuiceModule()).getInstance(ReferencePackageFactory.class);
ReferencePackage referencePackage = referencePackageFactory.create(5);
OtherPackage otherPackage = referencePackage.otherPackage();
assertThat(otherPackage.referencePackageFactory()).isNotSameInstanceAs(referencePackageFactory);
diff --git a/factory/src/main/java/com/google/auto/factory/AutoFactory.java b/factory/src/main/java/com/google/auto/factory/AutoFactory.java
index 2ef84cc..3b5d90e 100644
--- a/factory/src/main/java/com/google/auto/factory/AutoFactory.java
+++ b/factory/src/main/java/com/google/auto/factory/AutoFactory.java
@@ -32,7 +32,7 @@
*
* @author Gregory Kick
*/
-@Target({ TYPE, CONSTRUCTOR })
+@Target({TYPE, CONSTRUCTOR})
public @interface AutoFactory {
/**
* The <i>simple</i> name of the generated factory; the factory is always generated in the same
@@ -50,7 +50,7 @@
/**
* A list of interfaces that the generated factory is required to implement.
*/
- Class<?>[] implementing() default { };
+ Class<?>[] implementing() default {};
/**
* The type that the generated factory is require to extend.
diff --git a/factory/src/main/java/com/google/auto/factory/Provided.java b/factory/src/main/java/com/google/auto/factory/Provided.java
index e81e4aa..226a16f 100644
--- a/factory/src/main/java/com/google/auto/factory/Provided.java
+++ b/factory/src/main/java/com/google/auto/factory/Provided.java
@@ -26,4 +26,4 @@
* @author Gregory Kick
*/
@Target(PARAMETER)
-public @interface Provided { }
+public @interface Provided {}
diff --git a/factory/src/main/java/com/google/auto/factory/package-info.java b/factory/src/main/java/com/google/auto/factory/package-info.java
new file mode 100644
index 0000000..ea1ddd8
--- /dev/null
+++ b/factory/src/main/java/com/google/auto/factory/package-info.java
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.factory;
+
diff --git a/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java b/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java
index b767c47..53d38a4 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/AnnotationValues.java
@@ -32,24 +32,29 @@
static boolean asBoolean(AnnotationValue value) {
return value.accept(
new SimpleAnnotationValueVisitor6<Boolean, Void>() {
- @Override protected Boolean defaultAction(Object o, Void p) {
+ @Override
+ protected Boolean defaultAction(Object o, Void p) {
throw new IllegalArgumentException();
}
- @Override public Boolean visitBoolean(boolean b, Void p) {
+ @Override
+ public Boolean visitBoolean(boolean b, Void p) {
return b;
}
- }, null);
+ },
+ null);
}
static TypeElement asType(AnnotationValue value) {
return value.accept(
new SimpleAnnotationValueVisitor6<TypeElement, Void>() {
- @Override protected TypeElement defaultAction(Object o, Void p) {
+ @Override
+ protected TypeElement defaultAction(Object o, Void p) {
throw new IllegalArgumentException();
}
- @Override public TypeElement visitType(TypeMirror t, Void p) {
+ @Override
+ public TypeElement visitType(TypeMirror t, Void p) {
return t.accept(
new SimpleTypeVisitor6<TypeElement, Void>() {
@Override
@@ -59,12 +64,14 @@
@Override
public TypeElement visitDeclared(DeclaredType t, Void p) {
- return Iterables.getOnlyElement(ElementFilter.typesIn(
- ImmutableList.of(t.asElement())));
+ return Iterables.getOnlyElement(
+ ElementFilter.typesIn(ImmutableList.of(t.asElement())));
}
- }, null);
+ },
+ null);
}
- }, null);
+ },
+ null);
}
static ImmutableList<? extends AnnotationValue> asList(AnnotationValue value) {
@@ -80,6 +87,7 @@
List<? extends AnnotationValue> vals, Void p) {
return ImmutableList.copyOf(vals);
}
- }, null);
+ },
+ null);
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java
index e2da6ea..889d8e4 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryDeclaration.java
@@ -21,13 +21,13 @@
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static com.google.common.collect.Iterables.getOnlyElement;
+import static java.util.Objects.requireNonNull;
import static javax.lang.model.element.ElementKind.PACKAGE;
import static javax.lang.model.util.ElementFilter.typesIn;
import static javax.tools.Diagnostic.Kind.ERROR;
import com.google.auto.factory.AutoFactory;
import com.google.auto.value.AutoValue;
-import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
@@ -36,6 +36,7 @@
import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import javax.annotation.processing.Messager;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
@@ -54,12 +55,19 @@
@AutoValue
abstract class AutoFactoryDeclaration {
abstract TypeElement targetType();
+
abstract Element target();
+
abstract Optional<String> className();
+
abstract TypeElement extendingType();
+
abstract ImmutableSet<TypeElement> implementingTypes();
+
abstract boolean allowSubclasses();
+
abstract AnnotationMirror mirror();
+
abstract ImmutableMap<String, AnnotationValue> valuesMap();
PackageAndClass getFactoryName() {
@@ -97,52 +105,70 @@
Optional<AutoFactoryDeclaration> createIfValid(Element element) {
checkNotNull(element);
AnnotationMirror mirror = Mirrors.getAnnotationMirror(element, AutoFactory.class).get();
- checkArgument(Mirrors.getQualifiedName(mirror.getAnnotationType()).
- contentEquals(AutoFactory.class.getName()));
+ checkArgument(
+ Mirrors.getQualifiedName(mirror.getAnnotationType())
+ .contentEquals(AutoFactory.class.getName()));
Map<String, AnnotationValue> values =
Mirrors.simplifyAnnotationValueMap(elements.getElementValuesWithDefaults(mirror));
checkState(values.size() == 4);
- // className value is a string, so we can just call toString
- AnnotationValue classNameValue = values.get("className");
+ // className value is a string, so we can just call toString. We know values.get("className")
+ // is non-null because @AutoFactory has an annotation element of that name.
+ AnnotationValue classNameValue = requireNonNull(values.get("className"));
String className = classNameValue.getValue().toString();
if (!className.isEmpty() && !isValidIdentifier(className)) {
- messager.printMessage(ERROR,
+ messager.printMessage(
+ ERROR,
String.format("\"%s\" is not a valid Java identifier", className),
- element, mirror, classNameValue);
- return Optional.absent();
+ element,
+ mirror,
+ classNameValue);
+ return Optional.empty();
}
AnnotationValue extendingValue = checkNotNull(values.get("extending"));
TypeElement extendingType = AnnotationValues.asType(extendingValue);
if (extendingType == null) {
- messager.printMessage(ERROR, "Unable to find the type: "
- + extendingValue.getValue().toString(),
- element, mirror, extendingValue);
- return Optional.absent();
+ messager.printMessage(
+ ERROR,
+ "Unable to find the type: " + extendingValue.getValue(),
+ element,
+ mirror,
+ extendingValue);
+ return Optional.empty();
} else if (!isValidSupertypeForClass(extendingType)) {
- messager.printMessage(ERROR,
- String.format("%s is not a valid supertype for a factory. "
- + "Supertypes must be non-final classes.",
- extendingType.getQualifiedName()),
- element, mirror, extendingValue);
- return Optional.absent();
+ messager.printMessage(
+ ERROR,
+ String.format(
+ "%s is not a valid supertype for a factory. "
+ + "Supertypes must be non-final classes.",
+ extendingType.getQualifiedName()),
+ element,
+ mirror,
+ extendingValue);
+ return Optional.empty();
}
ImmutableList<ExecutableElement> noParameterConstructors =
FluentIterable.from(ElementFilter.constructorsIn(extendingType.getEnclosedElements()))
- .filter(new Predicate<ExecutableElement>() {
- @Override public boolean apply(ExecutableElement constructor) {
- return constructor.getParameters().isEmpty();
- }
- })
+ .filter(
+ new Predicate<ExecutableElement>() {
+ @Override
+ public boolean apply(ExecutableElement constructor) {
+ return constructor.getParameters().isEmpty();
+ }
+ })
.toList();
- if (noParameterConstructors.size() == 0) {
- messager.printMessage(ERROR,
- String.format("%s is not a valid supertype for a factory. "
- + "Factory supertypes must have a no-arg constructor.",
- extendingType.getQualifiedName()),
- element, mirror, extendingValue);
- return Optional.absent();
+ if (noParameterConstructors.isEmpty()) {
+ messager.printMessage(
+ ERROR,
+ String.format(
+ "%s is not a valid supertype for a factory. "
+ + "Factory supertypes must have a no-arg constructor.",
+ extendingType.getQualifiedName()),
+ element,
+ mirror,
+ extendingValue);
+ return Optional.empty();
} else if (noParameterConstructors.size() > 1) {
throw new IllegalStateException("Multiple constructors with no parameters??");
}
@@ -161,7 +187,7 @@
new AutoValue_AutoFactoryDeclaration(
getAnnotatedType(element),
element,
- className.isEmpty() ? Optional.<String>absent() : Optional.of(className),
+ className.isEmpty() ? Optional.empty() : Optional.of(className),
extendingType,
implementingTypes,
allowSubclasses,
diff --git a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java
index 5cc1d94..82349f2 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/AutoFactoryProcessor.java
@@ -19,7 +19,6 @@
import com.google.auto.factory.AutoFactory;
import com.google.auto.factory.Provided;
import com.google.auto.service.AutoService;
-import com.google.common.base.Optional;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableListMultimap;
@@ -30,7 +29,9 @@
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
+import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
@@ -83,8 +84,9 @@
try {
doProcess(roundEnv);
} catch (Throwable e) {
- messager.printMessage(Kind.ERROR, "Failed to process @AutoFactory annotations:\n"
- + Throwables.getStackTraceAsString(e));
+ messager.printMessage(
+ Kind.ERROR,
+ "Failed to process @AutoFactory annotations:\n" + Throwables.getStackTraceAsString(e));
}
return false;
}
@@ -127,49 +129,58 @@
simpleNamesToNames(indexedMethods.keySet());
FactoryWriter factoryWriter = new FactoryWriter(processingEnv, factoriesBeingCreated);
- indexedMethods.asMap().forEach(
- (factoryName, methodDescriptors) -> {
- // The sets of classes that are mentioned in the `extending` and `implementing` elements,
- // respectively, of the @AutoFactory annotations for this factory.
- ImmutableSet.Builder<TypeMirror> extending = newTypeSetBuilder();
- ImmutableSortedSet.Builder<TypeMirror> implementing = newTypeSetBuilder();
- boolean publicType = false;
- Boolean allowSubclasses = null;
- boolean skipCreation = false;
- for (FactoryMethodDescriptor methodDescriptor : methodDescriptors) {
- extending.add(methodDescriptor.declaration().extendingType().asType());
- for (TypeElement implementingType :
- methodDescriptor.declaration().implementingTypes()) {
- implementing.add(implementingType.asType());
- }
- publicType |= methodDescriptor.publicMethod();
- if (allowSubclasses == null) {
- allowSubclasses = methodDescriptor.declaration().allowSubclasses();
- } else if (!allowSubclasses.equals(methodDescriptor.declaration().allowSubclasses())) {
- skipCreation = true;
- messager.printMessage(Kind.ERROR,
- "Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.",
- methodDescriptor.declaration().target(),
- methodDescriptor.declaration().mirror(),
- methodDescriptor.declaration().valuesMap().get("allowSubclasses"));
- }
- }
- if (!skipCreation) {
- try {
- factoryWriter.writeFactory(
- FactoryDescriptor.create(
- factoryName,
- Iterables.getOnlyElement(extending.build()),
- implementing.build(),
- publicType,
- ImmutableSet.copyOf(methodDescriptors),
- implementationMethodDescriptors.get(factoryName),
- allowSubclasses));
- } catch (IOException e) {
- messager.printMessage(Kind.ERROR, "failed: " + e);
- }
- }
- });
+ indexedMethods
+ .asMap()
+ .forEach(
+ (factoryName, methodDescriptors) -> {
+ if (methodDescriptors.isEmpty()) {
+ // This shouldn't happen, but check anyway to avoid an exception for
+ // methodDescriptors.iterator().next() below.
+ return;
+ }
+ // The sets of classes that are mentioned in the `extending` and `implementing`
+ // elements, respectively, of the @AutoFactory annotations for this factory.
+ ImmutableSet.Builder<TypeMirror> extending = newTypeSetBuilder();
+ ImmutableSortedSet.Builder<TypeMirror> implementing = newTypeSetBuilder();
+ boolean publicType = false;
+ Set<Boolean> allowSubclassesSet = new HashSet<>();
+ boolean skipCreation = false;
+ for (FactoryMethodDescriptor methodDescriptor : methodDescriptors) {
+ extending.add(methodDescriptor.declaration().extendingType().asType());
+ for (TypeElement implementingType :
+ methodDescriptor.declaration().implementingTypes()) {
+ implementing.add(implementingType.asType());
+ }
+ publicType |= methodDescriptor.publicMethod();
+ allowSubclassesSet.add(methodDescriptor.declaration().allowSubclasses());
+ if (allowSubclassesSet.size() > 1) {
+ skipCreation = true;
+ messager.printMessage(
+ Kind.ERROR,
+ "Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.",
+ methodDescriptor.declaration().target(),
+ methodDescriptor.declaration().mirror(),
+ methodDescriptor.declaration().valuesMap().get("allowSubclasses"));
+ }
+ }
+ // The set can't be empty because we eliminated methodDescriptors.isEmpty() above.
+ boolean allowSubclasses = allowSubclassesSet.iterator().next();
+ if (!skipCreation) {
+ try {
+ factoryWriter.writeFactory(
+ FactoryDescriptor.create(
+ factoryName,
+ Iterables.getOnlyElement(extending.build()),
+ implementing.build(),
+ publicType,
+ ImmutableSet.copyOf(methodDescriptors),
+ implementationMethodDescriptors.get(factoryName),
+ allowSubclasses));
+ } catch (IOException e) {
+ messager.printMessage(Kind.ERROR, "failed: " + e);
+ }
+ }
+ });
}
private ImmutableSet<ImplementationMethodDescriptor> implementationMethods(
@@ -180,8 +191,7 @@
ElementFilter.methodsIn(elements.getAllMembers(supertype))) {
if (implementationMethod.getModifiers().contains(Modifier.ABSTRACT)) {
ExecutableType methodType =
- Elements2.getExecutableElementAsMemberOf(
- types, implementationMethod, supertype);
+ Elements2.getExecutableElementAsMemberOf(types, implementationMethod, supertype);
ImmutableSet<Parameter> passedParameters =
Parameter.forParameterList(
implementationMethod.getParameters(), methodType.getParameterTypes(), types);
@@ -192,6 +202,7 @@
.publicMethod()
.passedParameters(passedParameters)
.isVarArgs(implementationMethod.isVarArgs())
+ .exceptions(implementationMethod.getThrownTypes())
.build());
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Elements2.java b/factory/src/main/java/com/google/auto/factory/processor/Elements2.java
index 30230f7..3663f37 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Elements2.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Elements2.java
@@ -22,10 +22,10 @@
import static javax.lang.model.element.Modifier.FINAL;
import static javax.lang.model.element.Modifier.STATIC;
+import com.google.auto.common.MoreTypes;
import com.google.common.collect.ImmutableSet;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
@@ -33,7 +33,7 @@
import javax.lang.model.util.Types;
final class Elements2 {
- private Elements2() { }
+ private Elements2() {}
static ImmutableSet<ExecutableElement> getConstructors(TypeElement type) {
checkNotNull(type);
@@ -72,11 +72,11 @@
throw new IllegalStateException(
"Expected subTypeElement.asType() to return a class/interface type.");
}
- TypeMirror subExecutableTypeMirror = types.asMemberOf(
- (DeclaredType) subTypeMirror, executableElement);
+ TypeMirror subExecutableTypeMirror =
+ types.asMemberOf(MoreTypes.asDeclared(subTypeMirror), executableElement);
if (!subExecutableTypeMirror.getKind().equals(TypeKind.EXECUTABLE)) {
throw new IllegalStateException("Expected subExecutableTypeMirror to be an executable type.");
}
- return (ExecutableType) subExecutableTypeMirror;
+ return MoreTypes.asExecutable(subExecutableTypeMirror);
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java
index 5ed2307..019295f 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptor.java
@@ -17,16 +17,15 @@
import com.google.auto.value.AutoValue;
import com.google.common.base.CharMatcher;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
-import java.util.Collection;
+import com.google.common.collect.Streams;
import java.util.HashSet;
-import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.type.TypeMirror;
@@ -47,20 +46,28 @@
};
abstract PackageAndClass name();
+
abstract TypeMirror extendingType();
+
abstract ImmutableSet<TypeMirror> implementingTypes();
+
abstract boolean publicType();
+
abstract ImmutableSet<FactoryMethodDescriptor> methodDescriptors();
+
abstract ImmutableSet<ImplementationMethodDescriptor> implementationMethodDescriptors();
+
abstract boolean allowSubclasses();
+
abstract ImmutableMap<Key, ProviderField> providers();
final AutoFactoryDeclaration declaration() {
- return Iterables.getFirst(methodDescriptors(), null).declaration();
+ // There is always at least one method descriptor.
+ return methodDescriptors().iterator().next().declaration();
}
private static class UniqueNameSet {
- private final Set<String> uniqueNames = new HashSet<String>();
+ private final Set<String> uniqueNames = new HashSet<>();
/**
* Generates a unique name using {@code base}. If {@code base} has not yet been added, it will
@@ -92,33 +99,37 @@
}
ImmutableMap.Builder<Key, ProviderField> providersBuilder = ImmutableMap.builder();
UniqueNameSet uniqueNames = new UniqueNameSet();
- for (Entry<Key, Collection<Parameter>> entry :
- parametersForProviders.build().asMap().entrySet()) {
- Key key = entry.getKey();
- switch (entry.getValue().size()) {
- case 0:
- throw new AssertionError();
- case 1:
- Parameter parameter = Iterables.getOnlyElement(entry.getValue());
- providersBuilder.put(
- key,
- ProviderField.create(
- uniqueNames.getUniqueName(parameter.name() + "Provider"),
- key,
- parameter.nullable()));
- break;
- default:
- String providerName =
- uniqueNames.getUniqueName(
- invalidIdentifierCharacters.replaceFrom(key.toString(), '_') + "Provider");
- Optional<AnnotationMirror> nullable = Optional.absent();
- for (Parameter param : entry.getValue()) {
- nullable = nullable.or(param.nullable());
- }
- providersBuilder.put(key, ProviderField.create(providerName, key, nullable));
- break;
- }
- }
+ parametersForProviders
+ .build()
+ .asMap()
+ .forEach(
+ (key, parameters) -> {
+ switch (parameters.size()) {
+ case 0:
+ throw new AssertionError();
+ case 1:
+ Parameter parameter = Iterables.getOnlyElement(parameters);
+ providersBuilder.put(
+ key,
+ ProviderField.create(
+ uniqueNames.getUniqueName(parameter.name() + "Provider"),
+ key,
+ parameter.nullable()));
+ break;
+ default:
+ String providerName =
+ uniqueNames.getUniqueName(
+ invalidIdentifierCharacters.replaceFrom(key.toString(), '_')
+ + "Provider");
+ Optional<AnnotationMirror> nullable =
+ parameters.stream()
+ .map(Parameter::nullable)
+ .flatMap(Streams::stream)
+ .findFirst();
+ providersBuilder.put(key, ProviderField.create(providerName, key, nullable));
+ break;
+ }
+ });
ImmutableBiMap<FactoryMethodDescriptor, ImplementationMethodDescriptor>
duplicateMethodDescriptors =
@@ -129,8 +140,8 @@
getDeduplicatedMethodDescriptors(methodDescriptors, duplicateMethodDescriptors);
ImmutableSet<ImplementationMethodDescriptor> deduplicatedImplementationMethodDescriptors =
- ImmutableSet.copyOf(
- Sets.difference(implementationMethodDescriptors, duplicateMethodDescriptors.values()));
+ Sets.difference(implementationMethodDescriptors, duplicateMethodDescriptors.values())
+ .immutableCopy();
return new AutoValue_FactoryDescriptor(
name,
@@ -191,12 +202,12 @@
duplicateMethodDescriptors.get(methodDescriptor);
FactoryMethodDescriptor newMethodDescriptor =
- (duplicateMethodDescriptor != null)
- ? methodDescriptor
- .toBuilder()
+ (duplicateMethodDescriptor != null)
+ ? methodDescriptor.toBuilder()
.overridingMethod(true)
.publicMethod(duplicateMethodDescriptor.publicMethod())
.returnType(duplicateMethodDescriptor.returnType())
+ .exceptions(duplicateMethodDescriptor.exceptions())
.build()
: methodDescriptor;
deduplicatedMethodDescriptors.add(newMethodDescriptor);
@@ -213,8 +224,7 @@
* in the same order.
*/
private static boolean areDuplicateMethodDescriptors(
- FactoryMethodDescriptor factory,
- ImplementationMethodDescriptor implementation) {
+ FactoryMethodDescriptor factory, ImplementationMethodDescriptor implementation) {
if (!factory.name().equals(implementation.name())) {
return false;
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java
index d2331f4..70a21ea 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryDescriptorGenerator.java
@@ -18,6 +18,8 @@
import static com.google.auto.common.MoreElements.isAnnotationPresent;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.partitioningBy;
import static javax.lang.model.element.Modifier.ABSTRACT;
import static javax.lang.model.element.Modifier.PUBLIC;
import static javax.tools.Diagnostic.Kind.ERROR;
@@ -26,13 +28,11 @@
import com.google.auto.factory.AutoFactory;
import com.google.auto.factory.Provided;
import com.google.common.base.Function;
-import com.google.common.base.Functions;
-import com.google.common.base.Optional;
-import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Multimaps;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
import javax.annotation.processing.Messager;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
@@ -54,9 +54,7 @@
private final AutoFactoryDeclaration.Factory declarationFactory;
FactoryDescriptorGenerator(
- Messager messager,
- Types types,
- AutoFactoryDeclaration.Factory declarationFactory) {
+ Messager messager, Types types, AutoFactoryDeclaration.Factory declarationFactory) {
this.messager = messager;
this.types = types;
this.declarationFactory = declarationFactory;
@@ -68,70 +66,75 @@
if (!declaration.isPresent()) {
return ImmutableSet.of();
}
- return element.accept(new ElementKindVisitor6<ImmutableSet<FactoryMethodDescriptor>, Void>() {
- @Override
- protected ImmutableSet<FactoryMethodDescriptor> defaultAction(Element e, Void p) {
- throw new AssertionError("@AutoFactory applied to an impossible element");
- }
-
- @Override
- public ImmutableSet<FactoryMethodDescriptor> visitTypeAsClass(TypeElement type, Void p) {
- if (type.getModifiers().contains(ABSTRACT)) {
- // applied to an abstract factory
- messager.printMessage(ERROR,
- "Auto-factory doesn't support being applied to abstract classes.", type, mirror);
- return ImmutableSet.of();
- } else {
- // applied to the type to be created
- ImmutableSet<ExecutableElement> constructors = Elements2.getConstructors(type);
- if (constructors.isEmpty()) {
- return generateDescriptorForDefaultConstructor(declaration.get(), type);
- } else {
- return FluentIterable.from(constructors)
- .transform(new Function<ExecutableElement, FactoryMethodDescriptor>() {
- @Override public FactoryMethodDescriptor apply(ExecutableElement constructor) {
- return generateDescriptorForConstructor(declaration.get(), constructor);
- }
- })
- .toSet();
+ return element.accept(
+ new ElementKindVisitor6<ImmutableSet<FactoryMethodDescriptor>, Void>() {
+ @Override
+ protected ImmutableSet<FactoryMethodDescriptor> defaultAction(Element e, Void p) {
+ throw new AssertionError("@AutoFactory applied to an impossible element");
}
- }
- }
- @Override
- public ImmutableSet<FactoryMethodDescriptor> visitTypeAsInterface(TypeElement type, Void p) {
- // applied to the factory interface
- messager.printMessage(ERROR,
- "Auto-factory doesn't support being applied to interfaces.", type, mirror);
- return ImmutableSet.of();
- }
+ @Override
+ public ImmutableSet<FactoryMethodDescriptor> visitTypeAsClass(TypeElement type, Void p) {
+ if (type.getModifiers().contains(ABSTRACT)) {
+ // applied to an abstract factory
+ messager.printMessage(
+ ERROR,
+ "Auto-factory doesn't support being applied to abstract classes.",
+ type,
+ mirror);
+ return ImmutableSet.of();
+ } else {
+ // applied to the type to be created
+ ImmutableSet<ExecutableElement> constructors = Elements2.getConstructors(type);
+ if (constructors.isEmpty()) {
+ return generateDescriptorForDefaultConstructor(declaration.get(), type);
+ } else {
+ return FluentIterable.from(constructors)
+ .transform(
+ new Function<ExecutableElement, FactoryMethodDescriptor>() {
+ @Override
+ public FactoryMethodDescriptor apply(ExecutableElement constructor) {
+ return generateDescriptorForConstructor(declaration.get(), constructor);
+ }
+ })
+ .toSet();
+ }
+ }
+ }
- @Override
- public ImmutableSet<FactoryMethodDescriptor> visitExecutableAsConstructor(ExecutableElement e,
- Void p) {
- // applied to a constructor of a type to be created
- return ImmutableSet.of(generateDescriptorForConstructor(declaration.get(), e));
- }
- }, null);
+ @Override
+ public ImmutableSet<FactoryMethodDescriptor> visitTypeAsInterface(
+ TypeElement type, Void p) {
+ // applied to the factory interface
+ messager.printMessage(
+ ERROR, "Auto-factory doesn't support being applied to interfaces.", type, mirror);
+ return ImmutableSet.of();
+ }
+
+ @Override
+ public ImmutableSet<FactoryMethodDescriptor> visitExecutableAsConstructor(
+ ExecutableElement e, Void p) {
+ // applied to a constructor of a type to be created
+ return ImmutableSet.of(generateDescriptorForConstructor(declaration.get(), e));
+ }
+ },
+ null);
}
- FactoryMethodDescriptor generateDescriptorForConstructor(final AutoFactoryDeclaration declaration,
- ExecutableElement constructor) {
+ FactoryMethodDescriptor generateDescriptorForConstructor(
+ final AutoFactoryDeclaration declaration, ExecutableElement constructor) {
checkNotNull(constructor);
checkArgument(constructor.getKind() == ElementKind.CONSTRUCTOR);
TypeElement classElement = MoreElements.asType(constructor.getEnclosingElement());
- ImmutableListMultimap<Boolean, ? extends VariableElement> parameterMap =
- Multimaps.index(constructor.getParameters(), Functions.forPredicate(
- new Predicate<VariableElement>() {
- @Override
- public boolean apply(VariableElement parameter) {
- return isAnnotationPresent(parameter, Provided.class);
- }
- }));
+ Map<Boolean, List<VariableElement>> parameterMap =
+ constructor.getParameters().stream()
+ .collect(partitioningBy(parameter -> isAnnotationPresent(parameter, Provided.class)));
+ // The map returned by partitioningBy always has entries for both key values but our
+ // null-checker isn't yet smart enough to know that.
ImmutableSet<Parameter> providedParameters =
- Parameter.forParameterList(parameterMap.get(true), types);
+ Parameter.forParameterList(requireNonNull(parameterMap.get(true)), types);
ImmutableSet<Parameter> passedParameters =
- Parameter.forParameterList(parameterMap.get(false), types);
+ Parameter.forParameterList(requireNonNull(parameterMap.get(false)), types);
return FactoryMethodDescriptor.builder(declaration)
.name("create")
.returnType(classElement.asType())
@@ -140,6 +143,8 @@
.passedParameters(passedParameters)
.creationParameters(Parameter.forParameterList(constructor.getParameters(), types))
.isVarArgs(constructor.isVarArgs())
+ .exceptions(constructor.getThrownTypes())
+ .overridingMethod(false)
.build();
}
@@ -150,9 +155,12 @@
.name("create")
.returnType(type.asType())
.publicMethod(type.getModifiers().contains(PUBLIC))
- .passedParameters(ImmutableSet.<Parameter>of())
- .creationParameters(ImmutableSet.<Parameter>of())
- .providedParameters(ImmutableSet.<Parameter>of())
+ .providedParameters(ImmutableSet.of())
+ .passedParameters(ImmutableSet.of())
+ .creationParameters(ImmutableSet.of())
+ .isVarArgs(false)
+ .exceptions(ImmutableSet.of())
+ .overridingMethod(false)
.build());
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java
index 43e5097..4525957 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryMethodDescriptor.java
@@ -31,45 +31,65 @@
@AutoValue
abstract class FactoryMethodDescriptor {
abstract AutoFactoryDeclaration declaration();
+
abstract String name();
+
abstract TypeMirror returnType();
+
abstract boolean publicMethod();
+
abstract boolean overridingMethod();
+
abstract ImmutableSet<Parameter> passedParameters();
+
abstract ImmutableSet<Parameter> providedParameters();
+
abstract ImmutableSet<Parameter> creationParameters();
- abstract Builder toBuilder();
+
abstract boolean isVarArgs();
+ abstract ImmutableSet<TypeMirror> exceptions();
+
+ abstract Builder toBuilder();
+
final PackageAndClass factoryName() {
return declaration().getFactoryName();
}
static Builder builder(AutoFactoryDeclaration declaration) {
- return new AutoValue_FactoryMethodDescriptor.Builder()
- .declaration(checkNotNull(declaration))
- .publicMethod(false)
- .overridingMethod(false)
- .isVarArgs(false);
+ return new AutoValue_FactoryMethodDescriptor.Builder().declaration(checkNotNull(declaration));
}
@AutoValue.Builder
abstract static class Builder {
abstract Builder declaration(AutoFactoryDeclaration declaration);
+
abstract Builder name(String name);
+
abstract Builder returnType(TypeMirror returnType);
+
abstract Builder publicMethod(boolean publicMethod);
+
abstract Builder overridingMethod(boolean overridingMethod);
+
abstract Builder passedParameters(Iterable<Parameter> passedParameters);
+
abstract Builder providedParameters(Iterable<Parameter> providedParameters);
+
abstract Builder creationParameters(Iterable<Parameter> creationParameters);
+
abstract Builder isVarArgs(boolean isVarargs);
+
+ abstract Builder exceptions(Iterable<? extends TypeMirror> exceptions);
+
abstract FactoryMethodDescriptor buildImpl();
FactoryMethodDescriptor build() {
FactoryMethodDescriptor descriptor = buildImpl();
- checkState(descriptor.creationParameters().equals(
- Sets.union(descriptor.passedParameters(), descriptor.providedParameters())));
+ checkState(
+ descriptor
+ .creationParameters()
+ .equals(Sets.union(descriptor.passedParameters(), descriptor.providedParameters())));
return descriptor;
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java b/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
index 53b99cb..b7f9c3e 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/FactoryWriter.java
@@ -19,19 +19,22 @@
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.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
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 com.google.common.base.Function;
-import com.google.common.base.Joiner;
-import com.google.common.collect.FluentIterable;
+import com.google.auto.common.AnnotationMirrors;
+import com.google.auto.common.AnnotationValues;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
+import com.google.common.collect.Streams;
import com.squareup.javapoet.AnnotationSpec;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.CodeBlock;
@@ -43,13 +46,19 @@
import com.squareup.javapoet.TypeSpec;
import com.squareup.javapoet.TypeVariableName;
import java.io.IOException;
+import java.lang.annotation.Target;
import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.inject.Inject;
import javax.inject.Provider;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
@@ -71,14 +80,10 @@
this.factoriesBeingCreated = factoriesBeingCreated;
}
- private static final Joiner ARGUMENT_JOINER = Joiner.on(", ");
-
- void writeFactory(FactoryDescriptor descriptor)
- throws IOException {
+ void writeFactory(FactoryDescriptor descriptor) throws IOException {
String factoryName = descriptor.name().className();
TypeSpec.Builder factory =
- classBuilder(factoryName)
- .addOriginatingElement(descriptor.declaration().targetType());
+ classBuilder(factoryName).addOriginatingElement(descriptor.declaration().targetType());
generatedAnnotationSpec(
elements,
sourceVersion,
@@ -145,7 +150,7 @@
ImmutableSet<TypeVariableName> factoryTypeVariables) {
for (FactoryMethodDescriptor methodDescriptor : descriptor.methodDescriptors()) {
MethodSpec.Builder method =
- MethodSpec.methodBuilder(methodDescriptor.name())
+ methodBuilder(methodDescriptor.name())
.addTypeVariables(getMethodTypeVariables(methodDescriptor, factoryTypeVariables))
.returns(TypeName.get(methodDescriptor.returnType()))
.varargs(methodDescriptor.isVarArgs());
@@ -155,6 +160,8 @@
if (methodDescriptor.publicMethod()) {
method.addModifiers(PUBLIC);
}
+ method.addExceptions(
+ methodDescriptor.exceptions().stream().map(TypeName::get).collect(toList()));
CodeBlock.Builder args = CodeBlock.builder();
method.addParameters(parameters(methodDescriptor.passedParameters()));
Iterator<Parameter> parameters = methodDescriptor.creationParameters().iterator();
@@ -168,7 +175,7 @@
checkNotNull = false;
}
} else {
- ProviderField provider = descriptor.providers().get(parameter.key());
+ ProviderField provider = requireNonNull(descriptor.providers().get(parameter.key()));
argument = CodeBlock.of(provider.name());
if (parameter.isProvider()) {
// Providers are checked for nullness in the Factory's constructor.
@@ -190,8 +197,7 @@
}
}
- private void addImplementationMethods(
- TypeSpec.Builder factory, FactoryDescriptor descriptor) {
+ private void addImplementationMethods(TypeSpec.Builder factory, FactoryDescriptor descriptor) {
for (ImplementationMethodDescriptor methodDescriptor :
descriptor.implementationMethodDescriptors()) {
MethodSpec.Builder implementationMethod =
@@ -202,18 +208,12 @@
if (methodDescriptor.publicMethod()) {
implementationMethod.addModifiers(PUBLIC);
}
+ implementationMethod.addExceptions(
+ methodDescriptor.exceptions().stream().map(TypeName::get).collect(toList()));
implementationMethod.addParameters(parameters(methodDescriptor.passedParameters()));
implementationMethod.addStatement(
"return create($L)",
- FluentIterable.from(methodDescriptor.passedParameters())
- .transform(
- new Function<Parameter, String>() {
- @Override
- public String apply(Parameter parameter) {
- return parameter.name();
- }
- })
- .join(ARGUMENT_JOINER));
+ methodDescriptor.passedParameters().stream().map(Parameter::name).collect(joining(", ")));
factory.addMethod(implementationMethod.build());
}
}
@@ -225,17 +225,43 @@
private ImmutableList<ParameterSpec> parameters(Iterable<Parameter> parameters) {
ImmutableList.Builder<ParameterSpec> builder = ImmutableList.builder();
for (Parameter parameter : parameters) {
- ParameterSpec.Builder parameterBuilder =
- ParameterSpec.builder(resolveTypeName(parameter.type().get()), parameter.name());
- for (AnnotationMirror annotation :
- Iterables.concat(parameter.nullable().asSet(), parameter.key().qualifier().asSet())) {
- parameterBuilder.addAnnotation(AnnotationSpec.get(annotation));
- }
- builder.add(parameterBuilder.build());
+ TypeName type = resolveTypeName(parameter.type().get());
+ // Remove TYPE_USE annotations, since resolveTypeName will already have included those in
+ // the TypeName it returns.
+ List<AnnotationSpec> annotations =
+ Stream.of(parameter.nullable(), parameter.key().qualifier())
+ .flatMap(Streams::stream)
+ .filter(a -> !isTypeUseAnnotation(a))
+ .map(AnnotationSpec::get)
+ .collect(toList());
+ ParameterSpec parameterSpec =
+ ParameterSpec.builder(type, parameter.name()).addAnnotations(annotations).build();
+ builder.add(parameterSpec);
}
return builder.build();
}
+ private static boolean isTypeUseAnnotation(AnnotationMirror mirror) {
+ Element annotationElement = mirror.getAnnotationType().asElement();
+ // This is basically equivalent to:
+ // Target target = annotationElement.getAnnotation(Target.class);
+ // return target != null
+ // && Arrays.asList(annotationElement.getAnnotation(Target.class)).contains(TYPE_USE);
+ // but that might blow up if the annotation is being compiled at the same time and has an
+ // undefined identifier in its @Target values. The rigmarole below avoids that problem.
+ Optional<AnnotationMirror> maybeTargetMirror =
+ Mirrors.getAnnotationMirror(annotationElement, Target.class);
+ return maybeTargetMirror
+ .map(
+ targetMirror ->
+ AnnotationValues.getEnums(
+ AnnotationMirrors.getAnnotationValue(targetMirror, "value"))
+ .stream()
+ .map(VariableElement::getSimpleName)
+ .anyMatch(name -> name.contentEquals("TYPE_USE")))
+ .orElse(false);
+ }
+
private static void addCheckNotNullMethod(
TypeSpec.Builder factory, FactoryDescriptor descriptor) {
if (shouldGenerateCheckNotNull(descriptor)) {
@@ -290,17 +316,20 @@
* {@code @AutoFactory class Foo} has a constructor parameter of type {@code BarFactory} and
* {@code @AutoFactory class Bar} has a constructor parameter of type {@code FooFactory}. We did
* in fact find instances of this in Google's source base.
+ *
+ * <p>If the type has type annotations then include those in the returned {@link TypeName}.
*/
private TypeName resolveTypeName(TypeMirror type) {
- if (type.getKind() != TypeKind.ERROR) {
- return TypeName.get(type);
+ TypeName typeName = TypeName.get(type);
+ if (type.getKind() == TypeKind.ERROR) {
+ ImmutableSet<PackageAndClass> factoryNames = factoriesBeingCreated.get(type.toString());
+ if (factoryNames.size() == 1) {
+ PackageAndClass packageAndClass = Iterables.getOnlyElement(factoryNames);
+ typeName = ClassName.get(packageAndClass.packageName(), packageAndClass.className());
+ }
}
- ImmutableSet<PackageAndClass> factoryNames = factoriesBeingCreated.get(type.toString());
- if (factoryNames.size() == 1) {
- PackageAndClass packageAndClass = Iterables.getOnlyElement(factoryNames);
- return ClassName.get(packageAndClass.packageName(), packageAndClass.className());
- }
- return TypeName.get(type);
+ return typeName.annotated(
+ type.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(toList()));
}
private static ImmutableSet<TypeVariableName> getFactoryTypeVariables(
diff --git a/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java b/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java
index 9ddc249..b2705b7 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/ImplementationMethodDescriptor.java
@@ -22,21 +22,25 @@
@AutoValue
abstract class ImplementationMethodDescriptor {
abstract String name();
+
abstract TypeMirror returnType();
+
abstract boolean publicMethod();
+
abstract ImmutableSet<Parameter> passedParameters();
+
abstract boolean isVarArgs();
+ abstract ImmutableSet<TypeMirror> exceptions();
+
static Builder builder() {
- return new AutoValue_ImplementationMethodDescriptor.Builder()
- .publicMethod(true)
- .isVarArgs(false);
+ return new AutoValue_ImplementationMethodDescriptor.Builder();
}
@AutoValue.Builder
- static abstract class Builder {
+ abstract static class Builder {
abstract Builder name(String name);
-
+
abstract Builder returnType(TypeMirror returnTypeElement);
abstract Builder publicMethod(boolean publicMethod);
@@ -49,6 +53,8 @@
abstract Builder isVarArgs(boolean isVarargs);
+ abstract Builder exceptions(Iterable<? extends TypeMirror> exceptions);
+
abstract ImplementationMethodDescriptor build();
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Key.java b/factory/src/main/java/com/google/auto/factory/processor/Key.java
index 04bd4f3..728149e 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Key.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Key.java
@@ -24,9 +24,8 @@
import com.google.auto.common.MoreTypes;
import com.google.auto.value.AutoValue;
import com.google.common.base.Equivalence;
-import com.google.common.base.Optional;
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableSet;
+import java.util.Collection;
+import java.util.Optional;
import javax.inject.Qualifier;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.type.TypeMirror;
@@ -65,17 +64,15 @@
* <tr><td>{@code int} <td>{@code Integer}
* </table>
*/
- static Key create(
- TypeMirror type, Iterable<? extends AnnotationMirror> annotations, Types types) {
- ImmutableSet.Builder<AnnotationMirror> qualifiers = ImmutableSet.builder();
- for (AnnotationMirror annotation : annotations) {
- if (isAnnotationPresent(annotation.getAnnotationType().asElement(), Qualifier.class)) {
- qualifiers.add(annotation);
- }
- }
-
+ static Key create(TypeMirror type, Collection<AnnotationMirror> annotations, Types types) {
// TODO(gak): check for only one qualifier rather than using the first
- Optional<AnnotationMirror> qualifier = FluentIterable.from(qualifiers.build()).first();
+ Optional<AnnotationMirror> qualifier =
+ annotations.stream()
+ .filter(
+ annotation ->
+ isAnnotationPresent(
+ annotation.getAnnotationType().asElement(), Qualifier.class))
+ .findFirst();
TypeMirror keyType =
isProvider(type)
@@ -97,7 +94,7 @@
}
@Override
- public String toString() {
+ public final String toString() {
String typeQualifiedName = MoreTypes.asTypeElement(type().get()).toString();
return qualifier().isPresent()
? qualifier().get() + "/" + typeQualifiedName
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java b/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java
index c5b7d8b..313fc9e 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Mirrors.java
@@ -17,11 +17,11 @@
import com.google.auto.common.MoreTypes;
import com.google.common.base.Equivalence;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.lang.annotation.Annotation;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.inject.Provider;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
@@ -34,20 +34,23 @@
import javax.lang.model.util.SimpleElementVisitor6;
final class Mirrors {
- private Mirrors() { }
+ private Mirrors() {}
static Name getQualifiedName(DeclaredType type) {
- return type.asElement().accept(new SimpleElementVisitor6<Name, Void>() {
- @Override
- protected Name defaultAction(Element e, Void p) {
- throw new AssertionError("DeclaredTypes should be TypeElements");
- }
+ return type.asElement()
+ .accept(
+ new SimpleElementVisitor6<Name, Void>() {
+ @Override
+ protected Name defaultAction(Element e, Void p) {
+ throw new AssertionError("DeclaredTypes should be TypeElements");
+ }
- @Override
- public Name visitType(TypeElement e, Void p) {
- return e.getQualifiedName();
- }
- }, null);
+ @Override
+ public Name visitType(TypeElement e, Void p) {
+ return e.getQualifiedName();
+ }
+ },
+ null);
}
/** {@code true} if {@code type} is a {@link Provider}. */
@@ -62,8 +65,8 @@
static ImmutableMap<String, AnnotationValue> simplifyAnnotationValueMap(
Map<? extends ExecutableElement, ? extends AnnotationValue> annotationValueMap) {
ImmutableMap.Builder<String, AnnotationValue> builder = ImmutableMap.builder();
- for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entry
- : annotationValueMap.entrySet()) {
+ for (Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
+ annotationValueMap.entrySet()) {
builder.put(entry.getKey().getSimpleName().toString(), entry.getValue());
}
return builder.build();
@@ -73,15 +76,13 @@
* Get the {@link AnnotationMirror} for the type {@code annotationType} present on the given
* {@link Element} if it exists.
*/
- static Optional<AnnotationMirror> getAnnotationMirror(Element element,
- Class<? extends Annotation> annotationType) {
+ static Optional<AnnotationMirror> getAnnotationMirror(
+ Element element, Class<? extends Annotation> annotationType) {
String annotationName = annotationType.getName();
- for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
- if (getQualifiedName(annotationMirror.getAnnotationType()).contentEquals(annotationName)) {
- return Optional.of(annotationMirror);
- }
- }
- return Optional.absent();
+ return element.getAnnotationMirrors().stream()
+ .filter(a -> getQualifiedName(a.getAnnotationType()).contentEquals(annotationName))
+ .<AnnotationMirror>map(x -> x) // get rid of wildcard <? extends AnnotationMirror>
+ .findFirst();
}
/**
@@ -91,9 +92,7 @@
// TODO(ronshapiro): this is used in AutoFactory and Dagger, consider moving it into auto-common.
static <T> Optional<Equivalence.Wrapper<T>> wrapOptionalInEquivalence(
Equivalence<T> equivalence, Optional<T> optional) {
- return optional.isPresent()
- ? Optional.of(equivalence.wrap(optional.get()))
- : Optional.<Equivalence.Wrapper<T>>absent();
+ return optional.map(equivalence::wrap);
}
/**
@@ -102,8 +101,6 @@
*/
static <T> Optional<T> unwrapOptionalEquivalence(
Optional<Equivalence.Wrapper<T>> wrappedOptional) {
- return wrappedOptional.isPresent()
- ? Optional.of(wrappedOptional.get().get())
- : Optional.<T>absent();
+ return wrappedOptional.map(Equivalence.Wrapper::get);
}
}
diff --git a/factory/src/main/java/com/google/auto/factory/processor/Parameter.java b/factory/src/main/java/com/google/auto/factory/processor/Parameter.java
index 781225a..c5059ec 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/Parameter.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/Parameter.java
@@ -18,19 +18,20 @@
import static com.google.auto.factory.processor.Mirrors.unwrapOptionalEquivalence;
import static com.google.auto.factory.processor.Mirrors.wrapOptionalInEquivalence;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.stream.Collectors.toList;
import com.google.auto.common.AnnotationMirrors;
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.auto.value.AutoValue;
import com.google.common.base.Equivalence;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
+import java.util.stream.Stream;
import javax.inject.Provider;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.TypeElement;
@@ -63,6 +64,7 @@
abstract String name();
abstract Key key();
+
abstract Optional<Equivalence.Wrapper<AnnotationMirror>> nullableWrapper();
Optional<AnnotationMirror> nullable() {
@@ -71,15 +73,12 @@
private static Parameter forVariableElement(
VariableElement variable, TypeMirror type, Types types) {
- Optional<AnnotationMirror> nullable = Optional.absent();
- Iterable<? extends AnnotationMirror> annotations =
- Iterables.concat(variable.getAnnotationMirrors(), type.getAnnotationMirrors());
- for (AnnotationMirror annotation : annotations) {
- if (isNullable(annotation)) {
- nullable = Optional.of(annotation);
- break;
- }
- }
+ List<AnnotationMirror> annotations =
+ Stream.of(variable.getAnnotationMirrors(), type.getAnnotationMirrors())
+ .flatMap(List::stream)
+ .collect(toList());
+ Optional<AnnotationMirror> nullable =
+ annotations.stream().filter(Parameter::isNullable).findFirst();
Key key = Key.create(type, annotations, types);
return new AutoValue_Parameter(
@@ -108,7 +107,7 @@
Set<String> names = Sets.newHashSetWithExpectedSize(variables.size());
for (int i = 0; i < variables.size(); i++) {
Parameter parameter = forVariableElement(variables.get(i), variableTypes.get(i), types);
- checkArgument(names.add(parameter.name()));
+ checkArgument(names.add(parameter.name()), "Duplicate parameter name: %s", parameter.name());
builder.add(parameter);
}
ImmutableSet<Parameter> parameters = builder.build();
diff --git a/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java b/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java
index fe4c1fd..bd88f83 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/ProvidedChecker.java
@@ -26,6 +26,7 @@
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.ElementKindVisitor6;
+import org.checkerframework.checker.nullness.qual.Nullable;
final class ProvidedChecker {
private final Messager messager;
@@ -35,41 +36,54 @@
}
void checkProvidedParameter(Element element) {
- checkArgument(isAnnotationPresent(element, Provided.class), "%s not annoated with @Provided",
- element);
- element.accept(new ElementKindVisitor6<Void, Void>() {
- @Override
- protected Void defaultAction(Element e, Void p) {
- throw new AssertionError("Provided can only be applied to parameters");
- }
-
- @Override
- public Void visitVariableAsParameter(final VariableElement providedParameter, Void p) {
- providedParameter.getEnclosingElement().accept(new ElementKindVisitor6<Void, Void>() {
+ checkArgument(
+ isAnnotationPresent(element, Provided.class), "%s not annoated with @Provided", element);
+ element.accept(
+ new ElementKindVisitor6<@Nullable Void, @Nullable Void>() {
@Override
- protected Void defaultAction(Element e, Void p) {
- raiseError(providedParameter, "@%s may only be applied to constructor parameters");
- return null;
+ protected @Nullable Void defaultAction(Element e, @Nullable Void p) {
+ throw new AssertionError("Provided can only be applied to parameters");
}
@Override
- public Void visitExecutableAsConstructor(ExecutableElement constructor, Void p) {
- if (!(annotatedWithAutoFactory(constructor)
- || annotatedWithAutoFactory(constructor.getEnclosingElement()))) {
- raiseError(providedParameter,
- "@%s may only be applied to constructors requesting an auto-factory");
- }
+ public @Nullable Void visitVariableAsParameter(
+ VariableElement providedParameter, @Nullable Void p) {
+ providedParameter
+ .getEnclosingElement()
+ .accept(
+ new ElementKindVisitor6<@Nullable Void, @Nullable Void>() {
+ @Override
+ protected @Nullable Void defaultAction(Element e, @Nullable Void p) {
+ raiseError(
+ providedParameter, "@%s may only be applied to constructor parameters");
+ return null;
+ }
+
+ @Override
+ public @Nullable Void visitExecutableAsConstructor(
+ ExecutableElement constructor, @Nullable Void p) {
+ if (!(annotatedWithAutoFactory(constructor)
+ || annotatedWithAutoFactory(constructor.getEnclosingElement()))) {
+ raiseError(
+ providedParameter,
+ "@%s may only be applied to constructors requesting an auto-factory");
+ }
+ return null;
+ }
+ },
+ p);
return null;
}
- }, p);
- return null;
- }
- }, null);
+ },
+ null);
}
private void raiseError(VariableElement providedParameter, String messageFormat) {
- messager.printMessage(ERROR, String.format(messageFormat, Provided.class.getSimpleName()),
- providedParameter, Mirrors.getAnnotationMirror(providedParameter, Provided.class).get());
+ messager.printMessage(
+ ERROR,
+ String.format(messageFormat, Provided.class.getSimpleName()),
+ providedParameter,
+ Mirrors.getAnnotationMirror(providedParameter, Provided.class).get());
}
private static boolean annotatedWithAutoFactory(Element e) {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java b/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java
index 855c1fe..99847ec 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/ProviderField.java
@@ -21,13 +21,15 @@
import com.google.auto.common.AnnotationMirrors;
import com.google.auto.value.AutoValue;
import com.google.common.base.Equivalence;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.lang.model.element.AnnotationMirror;
@AutoValue
abstract class ProviderField {
abstract String name();
+
abstract Key key();
+
abstract Optional<Equivalence.Wrapper<AnnotationMirror>> nullableWrapper();
Optional<AnnotationMirror> nullable() {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java b/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java
index 1f89473..4bd546e 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/TypeVariables.java
@@ -38,8 +38,8 @@
return type.accept(ReferencedTypeVariables.INSTANCE, new HashSet<>());
}
- private static final class ReferencedTypeVariables extends
- SimpleTypeVisitor8<ImmutableSet<TypeVariable>, Set<Element>> {
+ private static final class ReferencedTypeVariables
+ extends SimpleTypeVisitor8<ImmutableSet<TypeVariable>, Set<Element>> {
private static final ReferencedTypeVariables INSTANCE = new ReferencedTypeVariables();
@@ -53,8 +53,7 @@
}
@Override
- public ImmutableSet<TypeVariable> visitDeclared(
- DeclaredType t, Set<Element> visited) {
+ public ImmutableSet<TypeVariable> visitDeclared(DeclaredType t, Set<Element> visited) {
if (!visited.add(t.asElement())) {
return ImmutableSet.of();
}
@@ -66,8 +65,7 @@
}
@Override
- public ImmutableSet<TypeVariable> visitTypeVariable(
- TypeVariable t, Set<Element> visited) {
+ public ImmutableSet<TypeVariable> visitTypeVariable(TypeVariable t, Set<Element> visited) {
if (!visited.add(t.asElement())) {
return ImmutableSet.of();
}
@@ -79,8 +77,7 @@
}
@Override
- public ImmutableSet<TypeVariable> visitUnion(
- UnionType t, Set<Element> visited) {
+ public ImmutableSet<TypeVariable> visitUnion(UnionType t, Set<Element> visited) {
ImmutableSet.Builder<TypeVariable> typeVariables = ImmutableSet.builder();
for (TypeMirror unionType : t.getAlternatives()) {
typeVariables.addAll(unionType.accept(this, visited));
@@ -89,8 +86,7 @@
}
@Override
- public ImmutableSet<TypeVariable> visitIntersection(
- IntersectionType t, Set<Element> visited) {
+ public ImmutableSet<TypeVariable> visitIntersection(IntersectionType t, Set<Element> visited) {
ImmutableSet.Builder<TypeVariable> typeVariables = ImmutableSet.builder();
for (TypeMirror intersectionType : t.getBounds()) {
typeVariables.addAll(intersectionType.accept(this, visited));
@@ -99,8 +95,7 @@
}
@Override
- public ImmutableSet<TypeVariable> visitWildcard(
- WildcardType t, Set<Element> visited) {
+ public ImmutableSet<TypeVariable> visitWildcard(WildcardType t, Set<Element> visited) {
ImmutableSet.Builder<TypeVariable> typeVariables = ImmutableSet.builder();
TypeMirror extendsBound = t.getExtendsBound();
if (extendsBound != null) {
diff --git a/factory/src/main/java/com/google/auto/factory/processor/package-info.java b/factory/src/main/java/com/google/auto/factory/processor/package-info.java
index 7339020..4a7c4b1 100644
--- a/factory/src/main/java/com/google/auto/factory/processor/package-info.java
+++ b/factory/src/main/java/com/google/auto/factory/processor/package-info.java
@@ -15,4 +15,5 @@
* This package contains the annotation processor that implements the
* {@link com.google.auto.factory.AutoFactory} API.
*/
-package com.google.auto.factory.processor;
\ No newline at end of file
+package com.google.auto.factory.processor;
+
diff --git a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java
index 1b23a65..7bef233 100644
--- a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java
+++ b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryDeclarationTest.java
@@ -24,7 +24,8 @@
@RunWith(JUnit4.class)
public class AutoFactoryDeclarationTest {
- @Test public void identifiers() {
+ @Test
+ public void identifiers() {
assertThat(isValidIdentifier("String")).isTrue();
assertThat(isValidIdentifier("9CantStartWithNumber")).isFalse();
assertThat(isValidIdentifier("enum")).isFalse();
diff --git a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
index 3088bb2..0df4c9c 100644
--- a/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
+++ b/factory/src/test/java/com/google/auto/factory/processor/AutoFactoryProcessorTest.java
@@ -15,15 +15,16 @@
*/
package com.google.auto.factory.processor;
-import static com.google.common.truth.Truth.assertAbout;
-import static com.google.testing.compile.JavaSourceSubjectFactory.javaSource;
-import static com.google.testing.compile.JavaSourcesSubject.assertThat;
-import static com.google.testing.compile.JavaSourcesSubjectFactory.javaSources;
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.TruthJUnit.assume;
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static java.lang.Math.max;
+import static java.lang.Math.min;
import static java.nio.charset.StandardCharsets.UTF_8;
-import com.google.common.collect.ImmutableSet;
import com.google.common.io.Resources;
-import com.google.testing.compile.CompilationRule;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.Compiler;
import com.google.testing.compile.JavaFileObjects;
import java.io.IOException;
import java.io.UncheckedIOException;
@@ -31,415 +32,489 @@
import java.util.List;
import javax.lang.model.SourceVersion;
import javax.tools.JavaFileObject;
-import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
-/**
- * Functional tests for the {@link AutoFactoryProcessor}.
- */
+/** Functional tests for the {@link AutoFactoryProcessor}. */
@RunWith(JUnit4.class)
public class AutoFactoryProcessorTest {
+ private final Compiler javac = Compiler.javac().withProcessors(new AutoFactoryProcessor());
- @Rule public final CompilationRule compilationRule = new CompilationRule();
+ @Test
+ public void simpleClass() {
+ Compilation compilation = javac.compile(JavaFileObjects.forResource("good/SimpleClass.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassFactory.java"));
+ }
- @Test public void simpleClass() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/SimpleClass.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassFactory.java"));
+ @Test
+ public void simpleClassWithConstructorThrowsClause() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/SimpleClassThrows.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassThrowsFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassThrowsFactory.java"));
}
@Test
public void nestedClasses() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/NestedClasses.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(
- loadExpectedFile("expected/NestedClasses_SimpleNestedClassFactory.java"),
- loadExpectedFile("expected/NestedClassCustomNamedFactory.java"));
+ Compilation compilation = javac.compile(JavaFileObjects.forResource("good/NestedClasses.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.NestedClasses_SimpleNestedClassFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/NestedClasses_SimpleNestedClassFactory.java"));
+ assertThat(compilation)
+ .generatedSourceFile("tests.NestedClassCustomNamedFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/NestedClassCustomNamedFactory.java"));
}
- @Test public void simpleClassNonFinal() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/SimpleClassNonFinal.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassNonFinalFactory.java"));
+ @Test
+ public void simpleClassNonFinal() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/SimpleClassNonFinal.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassNonFinalFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassNonFinalFactory.java"));
}
- @Test public void publicClass() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/PublicClass.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/PublicClassFactory.java"));
+ @Test
+ public void publicClass() {
+ Compilation compilation = javac.compile(JavaFileObjects.forResource("good/PublicClass.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.PublicClassFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/PublicClassFactory.java"));
}
- @Test public void simpleClassCustomName() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/SimpleClassCustomName.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/CustomNamedFactory.java"));
+ @Test
+ public void simpleClassCustomName() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/SimpleClassCustomName.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.CustomNamedFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/CustomNamedFactory.java"));
}
- @Test public void simpleClassMixedDeps() {
- assertAbout(javaSources())
- .that(
- ImmutableSet.of(
- JavaFileObjects.forResource("good/SimpleClassMixedDeps.java"),
- JavaFileObjects.forResource("support/AQualifier.java")))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassMixedDepsFactory.java"));
+ @Test
+ public void simpleClassMixedDeps() {
+ Compilation compilation =
+ javac.compile(
+ JavaFileObjects.forResource("good/SimpleClassMixedDeps.java"),
+ JavaFileObjects.forResource("support/AQualifier.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassMixedDepsFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassMixedDepsFactory.java"));
}
- @Test public void simpleClassPassedDeps() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/SimpleClassPassedDeps.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassPassedDepsFactory.java"));
+ @Test
+ public void simpleClassPassedDeps() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/SimpleClassPassedDeps.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassPassedDepsFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassPassedDepsFactory.java"));
}
- @Test public void simpleClassProvidedDeps() {
- assertAbout(javaSources())
- .that(
- ImmutableSet.of(
- JavaFileObjects.forResource("support/AQualifier.java"),
- JavaFileObjects.forResource("support/BQualifier.java"),
- JavaFileObjects.forResource("good/SimpleClassProvidedDeps.java")))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassProvidedDepsFactory.java"));
+ @Test
+ public void simpleClassProvidedDeps() {
+ Compilation compilation =
+ javac.compile(
+ JavaFileObjects.forResource("support/AQualifier.java"),
+ JavaFileObjects.forResource("support/BQualifier.java"),
+ JavaFileObjects.forResource("good/SimpleClassProvidedDeps.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassProvidedDepsFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassProvidedDepsFactory.java"));
}
@Test
public void simpleClassProvidedProviderDeps() {
- assertAbout(javaSources())
- .that(
- ImmutableSet.of(
- JavaFileObjects.forResource("support/AQualifier.java"),
- JavaFileObjects.forResource("support/BQualifier.java"),
- JavaFileObjects.forResource("good/SimpleClassProvidedProviderDeps.java")))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassProvidedProviderDepsFactory.java"));
+ Compilation compilation =
+ javac.compile(
+ JavaFileObjects.forResource("support/AQualifier.java"),
+ JavaFileObjects.forResource("support/BQualifier.java"),
+ JavaFileObjects.forResource("good/SimpleClassProvidedProviderDeps.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassProvidedProviderDepsFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/SimpleClassProvidedProviderDepsFactory.java"));
}
- @Test public void constructorAnnotated() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/ConstructorAnnotated.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/ConstructorAnnotatedFactory.java"));
+ @Test
+ public void constructorAnnotated() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/ConstructorAnnotated.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.ConstructorAnnotatedFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/ConstructorAnnotatedFactory.java"));
}
- @Test public void constructorAnnotatedNonFinal() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/ConstructorAnnotatedNonFinal.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/ConstructorAnnotatedNonFinalFactory.java"));
+ @Test
+ public void constructorWithThrowsClauseAnnotated() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/ConstructorAnnotatedThrows.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.ConstructorAnnotatedThrowsFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/ConstructorAnnotatedThrowsFactory.java"));
}
- @Test public void simpleClassImplementingMarker() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/SimpleClassImplementingMarker.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassImplementingMarkerFactory.java"));
+ @Test
+ public void constructorAnnotatedNonFinal() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/ConstructorAnnotatedNonFinal.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.ConstructorAnnotatedNonFinalFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/ConstructorAnnotatedNonFinalFactory.java"));
}
- @Test public void simpleClassImplementingSimpleInterface() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/SimpleClassImplementingSimpleInterface.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(
+ @Test
+ public void simpleClassImplementingMarker() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/SimpleClassImplementingMarker.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassImplementingMarkerFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/SimpleClassImplementingMarkerFactory.java"));
+ }
+
+ @Test
+ public void simpleClassImplementingSimpleInterface() {
+ Compilation compilation =
+ javac.compile(
+ JavaFileObjects.forResource("good/SimpleClassImplementingSimpleInterface.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassImplementingSimpleInterfaceFactory")
+ .hasSourceEquivalentTo(
loadExpectedFile("expected/SimpleClassImplementingSimpleInterfaceFactory.java"));
}
- @Test public void mixedDepsImplementingInterfaces() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/MixedDepsImplementingInterfaces.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/MixedDepsImplementingInterfacesFactory.java"));
+ @Test
+ public void mixedDepsImplementingInterfaces() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/MixedDepsImplementingInterfaces.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.MixedDepsImplementingInterfacesFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/MixedDepsImplementingInterfacesFactory.java"));
}
- @Test public void failsWithMixedFinals() {
+ @Test
+ public void failsWithMixedFinals() {
JavaFileObject file = JavaFileObjects.forResource("bad/MixedFinals.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining(
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
"Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.")
- .in(file).onLine(24)
- .and().withErrorContaining(
+ .inFile(file)
+ .onLine(24);
+ assertThat(compilation)
+ .hadErrorContaining(
"Cannot mix allowSubclasses=true and allowSubclasses=false in one factory.")
- .in(file).onLine(27);
+ .inFile(file)
+ .onLine(27);
}
- @Test public void providedButNoAutoFactory() {
+ @Test
+ public void providedButNoAutoFactory() {
JavaFileObject file = JavaFileObjects.forResource("bad/ProvidedButNoAutoFactory.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining(
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
"@Provided may only be applied to constructors requesting an auto-factory")
- .in(file).onLine(21).atColumn(38);
+ .inFile(file)
+ .onLineContaining("@Provided");
}
- @Test public void providedOnMethodParameter() {
+ @Test
+ public void providedOnMethodParameter() {
JavaFileObject file = JavaFileObjects.forResource("bad/ProvidedOnMethodParameter.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining(
- "@Provided may only be applied to constructor parameters")
- .in(file).onLine(21).atColumn(23);
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("@Provided may only be applied to constructor parameters")
+ .inFile(file)
+ .onLineContaining("@Provided");
}
- @Test public void invalidCustomName() {
+ @Test
+ public void invalidCustomName() {
JavaFileObject file = JavaFileObjects.forResource("bad/InvalidCustomName.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining("\"SillyFactory!\" is not a valid Java identifier")
- .in(file).onLine(20);
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("\"SillyFactory!\" is not a valid Java identifier")
+ .inFile(file)
+ .onLineContaining("SillyFactory!");
}
- @Test public void factoryExtendingAbstractClass() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/FactoryExtendingAbstractClass.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/FactoryExtendingAbstractClassFactory.java"));
+ @Test
+ public void factoryExtendingAbstractClass() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/FactoryExtendingAbstractClass.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.FactoryExtendingAbstractClassFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/FactoryExtendingAbstractClassFactory.java"));
}
- @Test public void factoryExtendingAbstractClass_withConstructorParams() {
+ @Test
+ public void factoryWithConstructorThrowsClauseExtendingAbstractClass() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/FactoryExtendingAbstractClassThrows.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.FactoryExtendingAbstractClassThrowsFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/FactoryExtendingAbstractClassThrowsFactory.java"));
+ }
+
+ @Test
+ public void factoryExtendingAbstractClass_withConstructorParams() {
JavaFileObject file =
- JavaFileObjects.forResource("good/FactoryExtendingAbstractClassWithConstructorParams.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining(
- "tests.FactoryExtendingAbstractClassWithConstructorParams.AbstractFactory "
- + "is not a valid supertype for a factory. "
- + "Factory supertypes must have a no-arg constructor.")
- .in(file).onLine(21);
+ JavaFileObjects.forResource("bad/FactoryExtendingAbstractClassWithConstructorParams.java");
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "tests.FactoryExtendingAbstractClassWithConstructorParams.AbstractFactory is not a"
+ + " valid supertype for a factory. Factory supertypes must have a no-arg"
+ + " constructor.")
+ .inFile(file)
+ .onLineContaining("@AutoFactory");
}
- @Test public void factoryExtendingAbstractClass_multipleConstructors() {
- JavaFileObject file = JavaFileObjects.forResource(
- "good/FactoryExtendingAbstractClassWithMultipleConstructors.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError();
+ @Test
+ public void factoryExtendingAbstractClass_multipleConstructors() {
+ JavaFileObject file =
+ JavaFileObjects.forResource(
+ "good/FactoryExtendingAbstractClassWithMultipleConstructors.java");
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).succeededWithoutWarnings();
}
- @Test public void factoryExtendingInterface() {
+ @Test
+ public void factoryExtendingInterface() {
JavaFileObject file = JavaFileObjects.forResource("bad/InterfaceSupertype.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining("java.lang.Runnable is not a valid supertype for a factory. "
- + "Supertypes must be non-final classes.")
- .in(file).onLine(20);
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "java.lang.Runnable is not a valid supertype for a factory. Supertypes must be"
+ + " non-final classes.")
+ .inFile(file)
+ .onLineContaining("@AutoFactory");
}
- @Test public void factoryExtendingEnum() {
+ @Test
+ public void factoryExtendingEnum() {
JavaFileObject file = JavaFileObjects.forResource("bad/EnumSupertype.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining(
- "java.util.concurrent.TimeUnit is not a valid supertype for a factory. "
- + "Supertypes must be non-final classes.")
- .in(file).onLine(21);
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "java.util.concurrent.TimeUnit is not a valid supertype for a factory. Supertypes must"
+ + " be non-final classes.")
+ .inFile(file)
+ .onLineContaining("@AutoFactory");
}
- @Test public void factoryExtendingFinalClass() {
+ @Test
+ public void factoryExtendingFinalClass() {
JavaFileObject file = JavaFileObjects.forResource("bad/FinalSupertype.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .failsToCompile()
- .withErrorContaining("java.lang.Boolean is not a valid supertype for a factory. "
- + "Supertypes must be non-final classes.")
- .in(file).onLine(20);
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "java.lang.Boolean is not a valid supertype for a factory. Supertypes must be"
+ + " non-final classes.")
+ .inFile(file)
+ .onLineContaining("@AutoFactory");
}
- @Test public void factoryImplementingGenericInterfaceExtension() {
+ @Test
+ public void factoryImplementingGenericInterfaceExtension() {
JavaFileObject file =
JavaFileObjects.forResource("good/FactoryImplementingGenericInterfaceExtension.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.FactoryImplementingGenericInterfaceExtensionFactory")
+ .hasSourceEquivalentTo(
loadExpectedFile("expected/FactoryImplementingGenericInterfaceExtensionFactory.java"));
}
- @Test public void multipleFactoriesImpementingInterface() {
+ @Test
+ public void multipleFactoriesImpementingInterface() {
JavaFileObject file =
JavaFileObjects.forResource("good/MultipleFactoriesImplementingInterface.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(
- loadExpectedFile("expected/MultipleFactoriesImplementingInterface_ClassAFactory.java"),
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.MultipleFactoriesImplementingInterface_ClassAFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/MultipleFactoriesImplementingInterface_ClassAFactory.java"));
+ assertThat(compilation)
+ .generatedSourceFile("tests.MultipleFactoriesImplementingInterface_ClassBFactory")
+ .hasSourceEquivalentTo(
loadExpectedFile("expected/MultipleFactoriesImplementingInterface_ClassBFactory.java"));
}
- @Test public void classUsingQualifierWithArgs() {
- assertAbout(javaSources())
- .that(
- ImmutableSet.of(
- JavaFileObjects.forResource("support/QualifierWithArgs.java"),
- JavaFileObjects.forResource("good/ClassUsingQualifierWithArgs.java")))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/ClassUsingQualifierWithArgsFactory.java"));
+ @Test
+ public void classUsingQualifierWithArgs() {
+ Compilation compilation =
+ javac.compile(
+ JavaFileObjects.forResource("support/QualifierWithArgs.java"),
+ JavaFileObjects.forResource("good/ClassUsingQualifierWithArgs.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.ClassUsingQualifierWithArgsFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/ClassUsingQualifierWithArgsFactory.java"));
}
- @Test public void factoryImplementingInterfaceWhichRedeclaresCreateMethods() {
- JavaFileObject file =
- JavaFileObjects.forResource("good/FactoryImplementingCreateMethod.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(
+ @Test
+ public void factoryImplementingInterfaceWhichRedeclaresCreateMethods() {
+ JavaFileObject file = JavaFileObjects.forResource("good/FactoryImplementingCreateMethod.java");
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.FactoryImplementingCreateMethod_ConcreteClassFactory")
+ .hasSourceEquivalentTo(
loadExpectedFile("expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java"));
}
- @Test public void nullableParams() {
- assertAbout(javaSources())
- .that(
- ImmutableSet.of(
- JavaFileObjects.forResource("good/SimpleClassNullableParameters.java"),
- JavaFileObjects.forResource("support/AQualifier.java"),
- JavaFileObjects.forResource("support/BQualifier.java")))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassNullableParametersFactory.java"));
+ @Test
+ public void nullableParams() {
+ Compilation compilation =
+ javac.compile(
+ JavaFileObjects.forResource("good/SimpleClassNullableParameters.java"),
+ JavaFileObjects.forResource("support/AQualifier.java"),
+ JavaFileObjects.forResource("support/BQualifier.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassNullableParametersFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/SimpleClassNullableParametersFactory.java"));
}
- @Test public void customNullableType() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/CustomNullable.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/CustomNullableFactory.java"));
+ @Test
+ public void customNullableType() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/CustomNullable.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.CustomNullableFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/CustomNullableFactory.java"));
}
- @Test public void checkerFrameworkNullableType() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/CheckerFrameworkNullable.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/CheckerFrameworkNullableFactory.java"));
+ @Test
+ public void checkerFrameworkNullableType() {
+ // TYPE_USE annotations are pretty much unusable with annotation processors on Java 8 because
+ // of bugs that mean they only appear in the javax.lang.model API when the compiler feels like
+ // it. Checking for a java.specification.version that does not start with "1." eliminates 8 and
+ // any earlier version.
+ assume().that(JAVA_SPECIFICATION_VERSION.value()).doesNotMatch("1\\..*");
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/CheckerFrameworkNullable.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.CheckerFrameworkNullableFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/CheckerFrameworkNullableFactory.java"));
}
- @Test public void multipleProvidedParamsWithSameKey() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/MultipleProvidedParamsSameKey.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/MultipleProvidedParamsSameKeyFactory.java"));
+ @Test
+ public void multipleProvidedParamsWithSameKey() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/MultipleProvidedParamsSameKey.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.MultipleProvidedParamsSameKeyFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/MultipleProvidedParamsSameKeyFactory.java"));
}
- @Test public void providerArgumentToCreateMethod() {
- assertAbout(javaSource())
- .that(JavaFileObjects.forResource("good/ProviderArgumentToCreateMethod.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/ProviderArgumentToCreateMethodFactory.java"));
+ @Test
+ public void providerArgumentToCreateMethod() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/ProviderArgumentToCreateMethod.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.ProviderArgumentToCreateMethodFactory")
+ .hasSourceEquivalentTo(
+ loadExpectedFile("expected/ProviderArgumentToCreateMethodFactory.java"));
}
- @Test public void multipleFactoriesConflictingParameterNames() {
- assertThat(
+ @Test
+ public void multipleFactoriesConflictingParameterNames() {
+ Compilation compilation =
+ javac.compile(
JavaFileObjects.forResource("good/MultipleFactoriesConflictingParameterNames.java"),
- JavaFileObjects.forResource("support/AQualifier.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(
+ JavaFileObjects.forResource("support/AQualifier.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.MultipleFactoriesConflictingParameterNamesFactory")
+ .hasSourceEquivalentTo(
loadExpectedFile("expected/MultipleFactoriesConflictingParameterNamesFactory.java"));
}
- @Test public void factoryVarargs() {
- assertThat(JavaFileObjects.forResource("good/SimpleClassVarargs.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/SimpleClassVarargsFactory.java"));
+ @Test
+ public void factoryVarargs() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/SimpleClassVarargs.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.SimpleClassVarargsFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/SimpleClassVarargsFactory.java"));
}
- @Test public void onlyPrimitives() {
- assertThat(JavaFileObjects.forResource("good/OnlyPrimitives.java"))
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/OnlyPrimitivesFactory.java"));
+ @Test
+ public void onlyPrimitives() {
+ Compilation compilation =
+ javac.compile(JavaFileObjects.forResource("good/OnlyPrimitives.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("tests.OnlyPrimitivesFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/OnlyPrimitivesFactory.java"));
}
@Test
public void defaultPackage() {
JavaFileObject file = JavaFileObjects.forResource("good/DefaultPackage.java");
- assertAbout(javaSource())
- .that(file)
- .processedWith(new AutoFactoryProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(loadExpectedFile("expected/DefaultPackageFactory.java"));
+ Compilation compilation = javac.compile(file);
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("DefaultPackageFactory")
+ .hasSourceEquivalentTo(loadExpectedFile("expected/DefaultPackageFactory.java"));
}
private JavaFileObject loadExpectedFile(String resourceName) {
+ if (isJavaxAnnotationProcessingGeneratedAvailable()) {
+ return JavaFileObjects.forResource(resourceName);
+ }
try {
List<String> sourceLines = Resources.readLines(Resources.getResource(resourceName), UTF_8);
- if (!isJavaxAnnotationProcessingGeneratedAvailable()) {
- replaceGeneratedImport(sourceLines);
- }
+ replaceGeneratedImport(sourceLines);
return JavaFileObjects.forSourceLines(
resourceName.replace('/', '.').replace(".java", ""), sourceLines);
} catch (IOException e) {
@@ -457,8 +532,8 @@
int lastImport = -1;
for (String line : sourceLines) {
if (line.startsWith("import ") && !line.startsWith("import static ")) {
- firstImport = Math.min(firstImport, i);
- lastImport = Math.max(lastImport, i);
+ firstImport = min(firstImport, i);
+ lastImport = max(lastImport, i);
}
i++;
}
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java b/factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java
similarity index 95%
rename from factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java
rename to factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java
index 98c5f66..7c7120b 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java
+++ b/factory/src/test/resources/bad/FactoryExtendingAbstractClassWithConstructorParams.java
@@ -20,9 +20,9 @@
@AutoFactory(extending = AbstractFactory.class)
final class FactoryExtendingAbstractClassWithConstructorParams {
- static abstract class AbstractFactory {
+ abstract static class AbstractFactory {
protected AbstractFactory(Object obj) {}
-
+
abstract FactoryExtendingAbstractClassWithConstructorParams newInstance();
}
}
diff --git a/factory/src/test/resources/bad/InvalidCustomName.java b/factory/src/test/resources/bad/InvalidCustomName.java
index 5734ee7..6d0a2f9 100644
--- a/factory/src/test/resources/bad/InvalidCustomName.java
+++ b/factory/src/test/resources/bad/InvalidCustomName.java
@@ -18,4 +18,4 @@
import com.google.auto.factory.AutoFactory;
@AutoFactory(className = "SillyFactory!")
-final class InvalidCustomName { }
+final class InvalidCustomName {}
diff --git a/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java b/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java
index 79175c7..faa8397 100644
--- a/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java
+++ b/factory/src/test/resources/expected/CheckerFrameworkNullableFactory.java
@@ -15,6 +15,7 @@
*/
package tests;
+import java.util.Map;
import javax.annotation.processing.Generated;
import javax.inject.Inject;
import javax.inject.Provider;
@@ -22,26 +23,34 @@
import org.checkerframework.checker.nullness.compatqual.NullableType;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
-)
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class CheckerFrameworkNullableFactory {
private final Provider<String> java_lang_StringProvider;
+ private final Provider<Map.@NullableType Entry<?, ?>> providedNestedNullableTypeProvider;
+
@Inject
CheckerFrameworkNullableFactory(
- Provider<String> java_lang_StringProvider) {
+ Provider<String> java_lang_StringProvider,
+ Provider<Map.@NullableType Entry<?, ?>> providedNestedNullableTypeProvider) {
this.java_lang_StringProvider = checkNotNull(java_lang_StringProvider, 1);
+ this.providedNestedNullableTypeProvider = checkNotNull(providedNestedNullableTypeProvider, 2);
}
CheckerFrameworkNullable create(
- @NullableDecl String nullableDecl, @NullableType String nullableType) {
+ @NullableDecl String nullableDecl,
+ @NullableType String nullableType,
+ Map.@NullableType Entry<?, ?> nestedNullableType) {
return new CheckerFrameworkNullable(
nullableDecl,
java_lang_StringProvider.get(),
nullableType,
- java_lang_StringProvider.get());
+ java_lang_StringProvider.get(),
+ nestedNullableType,
+ providedNestedNullableTypeProvider.get());
}
private static <T> T checkNotNull(T reference, int argumentIndex) {
diff --git a/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java b/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
index b5bd89c..8d889ee 100644
--- a/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
+++ b/factory/src/test/resources/expected/ClassUsingQualifierWithArgsFactory.java
@@ -20,14 +20,15 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class ClassUsingQualifierWithArgsFactory {
private final Provider<String> providedDepAProvider;
- @Inject ClassUsingQualifierWithArgsFactory(
- @QualifierWithArgs(name="Fred", count=3) Provider<String> providedDepAProvider) {
+ @Inject
+ ClassUsingQualifierWithArgsFactory(
+ @QualifierWithArgs(name = "Fred", count = 3) Provider<String> providedDepAProvider) {
this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
}
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
index 6e9d242..2234985 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedFactory.java
@@ -20,13 +20,14 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class ConstructorAnnotatedFactory {
private final Provider<Object> objProvider;
- @Inject ConstructorAnnotatedFactory(Provider<Object> objProvider) {
+ @Inject
+ ConstructorAnnotatedFactory(Provider<Object> objProvider) {
this.objProvider = checkNotNull(objProvider, 1);
}
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
index f662642..25ec894 100644
--- a/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedNonFinalFactory.java
@@ -20,13 +20,14 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
class ConstructorAnnotatedNonFinalFactory {
private final Provider<Object> objProvider;
- @Inject ConstructorAnnotatedNonFinalFactory(Provider<Object> objProvider) {
+ @Inject
+ ConstructorAnnotatedNonFinalFactory(Provider<Object> objProvider) {
this.objProvider = checkNotNull(objProvider, 1);
}
diff --git a/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java b/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java
new file mode 100644
index 0000000..05b30fd
--- /dev/null
+++ b/factory/src/test/resources/expected/ConstructorAnnotatedThrowsFactory.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 tests;
+
+import java.io.IOException;
+import javax.annotation.processing.Generated;
+import javax.inject.Inject;
+import javax.inject.Provider;
+
+@Generated(
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
+final class ConstructorAnnotatedThrowsFactory {
+ private final Provider<Object> objProvider;
+
+ @Inject
+ ConstructorAnnotatedThrowsFactory(Provider<Object> objProvider) {
+ this.objProvider = checkNotNull(objProvider, 1);
+ }
+
+ ConstructorAnnotatedThrows create() throws IOException, InterruptedException {
+ return new ConstructorAnnotatedThrows();
+ }
+
+ ConstructorAnnotatedThrows create(String s) {
+ return new ConstructorAnnotatedThrows(checkNotNull(s, 1));
+ }
+
+ ConstructorAnnotatedThrows create(int i) throws IOException {
+ return new ConstructorAnnotatedThrows(checkNotNull(objProvider.get(), 1), i);
+ }
+
+ ConstructorAnnotatedThrows create(char c) throws InterruptedException {
+ return new ConstructorAnnotatedThrows(checkNotNull(objProvider.get(), 1), c);
+ }
+
+ private static <T> T checkNotNull(T reference, int argumentIndex) {
+ if (reference == null) {
+ throw new NullPointerException(
+ "@AutoFactory method argument is null but is not marked @Nullable. Argument index: "
+ + argumentIndex);
+ }
+ return reference;
+ }
+}
diff --git a/factory/src/test/resources/expected/CustomNamedFactory.java b/factory/src/test/resources/expected/CustomNamedFactory.java
index c388387..512c244 100644
--- a/factory/src/test/resources/expected/CustomNamedFactory.java
+++ b/factory/src/test/resources/expected/CustomNamedFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class CustomNamedFactory {
- @Inject CustomNamedFactory() {}
+ @Inject
+ CustomNamedFactory() {}
SimpleClassCustomName create() {
return new SimpleClassCustomName();
diff --git a/factory/src/test/resources/expected/CustomNullableFactory.java b/factory/src/test/resources/expected/CustomNullableFactory.java
index 31bb5bf..c8f2f28 100644
--- a/factory/src/test/resources/expected/CustomNullableFactory.java
+++ b/factory/src/test/resources/expected/CustomNullableFactory.java
@@ -20,9 +20,9 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class CustomNullableFactory {
private final Provider<Object> objectProvider;
diff --git a/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java b/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java
index c56afb0..f35b414 100644
--- a/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java
+++ b/factory/src/test/resources/expected/FactoryExtendingAbstractClassFactory.java
@@ -19,18 +19,20 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class FactoryExtendingAbstractClassFactory
extends FactoryExtendingAbstractClass.AbstractFactory {
- @Inject FactoryExtendingAbstractClassFactory() {}
+ @Inject
+ FactoryExtendingAbstractClassFactory() {}
FactoryExtendingAbstractClass create() {
return new FactoryExtendingAbstractClass();
}
- @Override public FactoryExtendingAbstractClass newInstance() {
+ @Override
+ public FactoryExtendingAbstractClass newInstance() {
return create();
}
}
diff --git a/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java b/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java
new file mode 100644
index 0000000..402f894
--- /dev/null
+++ b/factory/src/test/resources/expected/FactoryExtendingAbstractClassThrowsFactory.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 tests;
+
+import java.io.IOException;
+import javax.annotation.processing.Generated;
+import javax.inject.Inject;
+
+@Generated(
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
+final class FactoryExtendingAbstractClassThrowsFactory
+ extends FactoryExtendingAbstractClassThrows.AbstractFactory {
+ @Inject
+ FactoryExtendingAbstractClassThrowsFactory() {}
+
+ FactoryExtendingAbstractClassThrows create() throws IOException, InterruptedException {
+ return new FactoryExtendingAbstractClassThrows();
+ }
+
+ @Override
+ public FactoryExtendingAbstractClassThrows newInstance() throws Exception {
+ return create();
+ }
+}
diff --git a/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java b/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
index f23dc9a..2d8a392 100644
--- a/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
+++ b/factory/src/test/resources/expected/FactoryImplementingCreateMethod_ConcreteClassFactory.java
@@ -20,9 +20,9 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class FactoryImplementingCreateMethod_ConcreteClassFactory
implements FactoryImplementingCreateMethod.FactoryInterfaceWithCreateMethod {
@@ -40,7 +40,8 @@
}
@Override
- public FactoryImplementingCreateMethod.ConcreteClass create(List<Integer> genericWithDifferentArgumentName) {
+ public FactoryImplementingCreateMethod.ConcreteClass create(
+ List<Integer> genericWithDifferentArgumentName) {
return new FactoryImplementingCreateMethod.ConcreteClass(
checkNotNull(genericWithDifferentArgumentName, 1));
}
diff --git a/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java b/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
index 3bfc526..9f2bf0a 100644
--- a/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
+++ b/factory/src/test/resources/expected/FactoryImplementingGenericInterfaceExtensionFactory.java
@@ -20,20 +20,23 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class FactoryImplementingGenericInterfaceExtensionFactory
implements FactoryImplementingGenericInterfaceExtension.MyFactory {
private final Provider<String> sProvider;
+
@Inject
FactoryImplementingGenericInterfaceExtensionFactory(Provider<String> sProvider) {
this.sProvider = checkNotNull(sProvider, 1);
}
+
FactoryImplementingGenericInterfaceExtension create(Integer i) {
return new FactoryImplementingGenericInterfaceExtension(
checkNotNull(sProvider.get(), 1), checkNotNull(i, 2));
}
+
@Override
public FactoryImplementingGenericInterfaceExtension make(Integer arg) {
return create(arg);
diff --git a/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java b/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
index 19f2c13..ec4089b 100644
--- a/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
+++ b/factory/src/test/resources/expected/MixedDepsImplementingInterfacesFactory.java
@@ -23,15 +23,18 @@
* @author Gregory Kick
*/
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
-)
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class MixedDepsImplementingInterfacesFactory
- implements MixedDepsImplementingInterfaces.FromInt, MixedDepsImplementingInterfaces.FromObject,
- MixedDepsImplementingInterfaces.MarkerA, MixedDepsImplementingInterfaces.MarkerB {
+ implements MixedDepsImplementingInterfaces.FromInt,
+ MixedDepsImplementingInterfaces.FromObject,
+ MixedDepsImplementingInterfaces.MarkerA,
+ MixedDepsImplementingInterfaces.MarkerB {
private final Provider<String> sProvider;
- @Inject MixedDepsImplementingInterfacesFactory(Provider<String> sProvider) {
+ @Inject
+ MixedDepsImplementingInterfacesFactory(Provider<String> sProvider) {
this.sProvider = checkNotNull(sProvider, 1);
}
@@ -43,11 +46,13 @@
return new MixedDepsImplementingInterfaces(checkNotNull(o, 1));
}
- @Override public MixedDepsImplementingInterfaces fromInt(int i) {
+ @Override
+ public MixedDepsImplementingInterfaces fromInt(int i) {
return create(i);
}
- @Override public MixedDepsImplementingInterfaces fromObject(Object o) {
+ @Override
+ public MixedDepsImplementingInterfaces fromObject(Object o) {
return create(o);
}
diff --git a/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java b/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
index fac6e13..3eaf3af 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesConflictingParameterNamesFactory.java
@@ -22,7 +22,7 @@
@Generated(
value = "com.google.auto.factory.processor.AutoFactoryProcessor",
comments = "https://github.com/google/auto/tree/master/factory"
-)
+ )
final class MultipleFactoriesConflictingParameterNamesFactory {
private final Provider<String> stringProvider;
diff --git a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java
index 5ee2b2f..6fcfb03 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassAFactory.java
@@ -19,9 +19,9 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class MultipleFactoriesImplementingInterface_ClassAFactory
implements MultipleFactoriesImplementingInterface.Base.Factory {
@Inject
diff --git a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java
index f654068..5664689 100644
--- a/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java
+++ b/factory/src/test/resources/expected/MultipleFactoriesImplementingInterface_ClassBFactory.java
@@ -19,9 +19,9 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class MultipleFactoriesImplementingInterface_ClassBFactory
implements MultipleFactoriesImplementingInterface.Base.Factory {
@Inject
diff --git a/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java b/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
index de7bad7..97cc8ac 100644
--- a/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
+++ b/factory/src/test/resources/expected/MultipleProvidedParamsSameKeyFactory.java
@@ -20,9 +20,9 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class MultipleProvidedParamsSameKeyFactory {
private final Provider<String> java_lang_StringProvider;
diff --git a/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java b/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java
index bf6a468..fe7aa1a 100644
--- a/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java
+++ b/factory/src/test/resources/expected/NestedClassCustomNamedFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class NestedClassCustomNamedFactory {
- @Inject NestedClassCustomNamedFactory() {}
+ @Inject
+ NestedClassCustomNamedFactory() {}
NestedClasses.SimpleNestedClassWithCustomFactory create() {
return new NestedClasses.SimpleNestedClassWithCustomFactory();
diff --git a/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java b/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java
index f982e86..41ecc52 100644
--- a/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java
+++ b/factory/src/test/resources/expected/NestedClasses_SimpleNestedClassFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class NestedClasses_SimpleNestedClassFactory {
- @Inject NestedClasses_SimpleNestedClassFactory() {}
+ @Inject
+ NestedClasses_SimpleNestedClassFactory() {}
NestedClasses.SimpleNestedClass create() {
return new NestedClasses.SimpleNestedClass();
diff --git a/factory/src/test/resources/expected/OnlyPrimitivesFactory.java b/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
index ec60c58..b931a22 100644
--- a/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
+++ b/factory/src/test/resources/expected/OnlyPrimitivesFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class OnlyPrimitivesFactory {
- @Inject OnlyPrimitivesFactory() {}
+ @Inject
+ OnlyPrimitivesFactory() {}
OnlyPrimitives create(int i, long l) {
return new OnlyPrimitives(i, l);
diff --git a/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java b/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
index 4d1a4cf..75a6291 100644
--- a/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
+++ b/factory/src/test/resources/expected/ProviderArgumentToCreateMethodFactory.java
@@ -22,10 +22,11 @@
@Generated(
value = "com.google.auto.factory.processor.AutoFactoryProcessor",
comments = "https://github.com/google/auto/tree/master/factory"
-)
+ )
final class ProviderArgumentToCreateMethodFactory
- implements ProviderArgumentToCreateMethod.CustomCreator{
- @Inject ProviderArgumentToCreateMethodFactory() {}
+ implements ProviderArgumentToCreateMethod.CustomCreator {
+ @Inject
+ ProviderArgumentToCreateMethodFactory() {}
ProviderArgumentToCreateMethod create(Provider<String> stringProvider) {
return new ProviderArgumentToCreateMethod(checkNotNull(stringProvider, 1));
diff --git a/factory/src/test/resources/expected/PublicClassFactory.java b/factory/src/test/resources/expected/PublicClassFactory.java
index 06671dc..9e5c113 100644
--- a/factory/src/test/resources/expected/PublicClassFactory.java
+++ b/factory/src/test/resources/expected/PublicClassFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
public final class PublicClassFactory {
- @Inject public PublicClassFactory() {}
+ @Inject
+ public PublicClassFactory() {}
public PublicClass create() {
return new PublicClass();
diff --git a/factory/src/test/resources/expected/SimpleClassFactory.java b/factory/src/test/resources/expected/SimpleClassFactory.java
index 308d2cd..4741b75 100644
--- a/factory/src/test/resources/expected/SimpleClassFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassFactory {
- @Inject SimpleClassFactory() {}
+ @Inject
+ SimpleClassFactory() {}
SimpleClass create() {
return new SimpleClass();
diff --git a/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java b/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java
index 6c611e9..1770138 100644
--- a/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassImplementingMarkerFactory.java
@@ -20,11 +20,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassImplementingMarkerFactory implements RandomAccess {
- @Inject SimpleClassImplementingMarkerFactory() {}
+ @Inject
+ SimpleClassImplementingMarkerFactory() {}
SimpleClassImplementingMarker create() {
return new SimpleClassImplementingMarker();
diff --git a/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java b/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java
index 720e7d0..7dd91be 100644
--- a/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassImplementingSimpleInterfaceFactory.java
@@ -19,18 +19,20 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassImplementingSimpleInterfaceFactory
implements SimpleClassImplementingSimpleInterface.SimpleInterface {
- @Inject SimpleClassImplementingSimpleInterfaceFactory() {}
+ @Inject
+ SimpleClassImplementingSimpleInterfaceFactory() {}
SimpleClassImplementingSimpleInterface create() {
return new SimpleClassImplementingSimpleInterface();
}
- @Override public SimpleClassImplementingSimpleInterface newInstance() {
+ @Override
+ public SimpleClassImplementingSimpleInterface newInstance() {
return create();
}
}
diff --git a/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
index ccdea61..b69ea32 100644
--- a/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassMixedDepsFactory.java
@@ -20,14 +20,14 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassMixedDepsFactory {
private final Provider<String> providedDepAProvider;
- @Inject SimpleClassMixedDepsFactory(
- @AQualifier Provider<String> providedDepAProvider) {
+ @Inject
+ SimpleClassMixedDepsFactory(@AQualifier Provider<String> providedDepAProvider) {
this.providedDepAProvider = checkNotNull(providedDepAProvider, 1);
}
diff --git a/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java b/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java
index d323812..5ab9030 100644
--- a/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassNonFinalFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
class SimpleClassNonFinalFactory {
- @Inject SimpleClassNonFinalFactory() {}
+ @Inject
+ SimpleClassNonFinalFactory() {}
SimpleClassNonFinal create() {
return new SimpleClassNonFinal();
diff --git a/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java b/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
index e354038..5b95596 100644
--- a/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassNullableParametersFactory.java
@@ -21,9 +21,9 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassNullableParametersFactory {
private final Provider<String> providedNullableProvider;
diff --git a/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
index 3260c36..9cc8a16 100644
--- a/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassPassedDepsFactory.java
@@ -19,11 +19,12 @@
import javax.inject.Inject;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassPassedDepsFactory {
- @Inject SimpleClassPassedDepsFactory() {}
+ @Inject
+ SimpleClassPassedDepsFactory() {}
SimpleClassPassedDeps create(String depA, String depB) {
return new SimpleClassPassedDeps(checkNotNull(depA, 1), checkNotNull(depB, 2));
diff --git a/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java b/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
index 05d1e5a..52448aa 100644
--- a/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassProvidedDepsFactory.java
@@ -20,9 +20,9 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassProvidedDepsFactory {
private final Provider<Integer> providedPrimitiveAProvider;
private final Provider<Integer> providedPrimitiveBProvider;
diff --git a/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java b/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
index aafdcec..7bf2372 100644
--- a/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassProvidedProviderDepsFactory.java
@@ -20,9 +20,9 @@
import javax.inject.Provider;
@Generated(
- value = "com.google.auto.factory.processor.AutoFactoryProcessor",
- comments = "https://github.com/google/auto/tree/master/factory"
- )
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
final class SimpleClassProvidedProviderDepsFactory {
private final Provider<String> providedDepAProvider;
private final Provider<String> providedDepBProvider;
diff --git a/factory/src/test/resources/expected/SimpleClassThrowsFactory.java b/factory/src/test/resources/expected/SimpleClassThrowsFactory.java
new file mode 100644
index 0000000..eda503a
--- /dev/null
+++ b/factory/src/test/resources/expected/SimpleClassThrowsFactory.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 tests;
+
+import java.io.IOException;
+import javax.annotation.processing.Generated;
+import javax.inject.Inject;
+
+@Generated(
+ value = "com.google.auto.factory.processor.AutoFactoryProcessor",
+ comments = "https://github.com/google/auto/tree/master/factory"
+ )
+final class SimpleClassThrowsFactory {
+ @Inject
+ SimpleClassThrowsFactory() {}
+
+ SimpleClassThrows create() throws IOException, InterruptedException {
+ return new SimpleClassThrows();
+ }
+}
diff --git a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
index 51c7f46..ac7c4bd 100644
--- a/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
+++ b/factory/src/test/resources/expected/SimpleClassVarargsFactory.java
@@ -21,9 +21,10 @@
@Generated(
value = "com.google.auto.factory.processor.AutoFactoryProcessor",
comments = "https://github.com/google/auto/tree/master/factory"
-)
+ )
final class SimpleClassVarargsFactory implements SimpleClassVarargs.InterfaceWithVarargs {
- @Inject SimpleClassVarargsFactory() {}
+ @Inject
+ SimpleClassVarargsFactory() {}
SimpleClassVarargs create(String... args) {
return new SimpleClassVarargs(checkNotNull(args, 1));
diff --git a/factory/src/test/resources/good/CheckerFrameworkNullable.java b/factory/src/test/resources/good/CheckerFrameworkNullable.java
index 7f2a0fe..8b9cbc2 100644
--- a/factory/src/test/resources/good/CheckerFrameworkNullable.java
+++ b/factory/src/test/resources/good/CheckerFrameworkNullable.java
@@ -17,6 +17,7 @@
import com.google.auto.factory.AutoFactory;
import com.google.auto.factory.Provided;
+import java.util.Map;
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
import org.checkerframework.checker.nullness.compatqual.NullableType;
@@ -27,5 +28,7 @@
@NullableDecl String nullableDecl,
@Provided @NullableDecl String providedNullableDecl,
@NullableType String nullableType,
- @Provided @NullableType String providedNullableType) {}
+ @Provided @NullableType String providedNullableType,
+ Map.@NullableType Entry<?, ?> nestedNullableType,
+ @Provided Map.@NullableType Entry<?, ?> providedNestedNullableType) {}
}
diff --git a/factory/src/test/resources/good/ConstructorAnnotated.java b/factory/src/test/resources/good/ConstructorAnnotated.java
index fdc02f3..ddb154f 100644
--- a/factory/src/test/resources/good/ConstructorAnnotated.java
+++ b/factory/src/test/resources/good/ConstructorAnnotated.java
@@ -19,9 +19,17 @@
import com.google.auto.factory.Provided;
final class ConstructorAnnotated {
- @AutoFactory ConstructorAnnotated() {}
+ @AutoFactory
+ ConstructorAnnotated() {}
+
ConstructorAnnotated(Object obj) {}
- @AutoFactory ConstructorAnnotated(String s) {}
- @AutoFactory ConstructorAnnotated(@Provided Object obj, int i) {}
- @AutoFactory ConstructorAnnotated(@Provided Object obj, char c) {}
+
+ @AutoFactory
+ ConstructorAnnotated(String s) {}
+
+ @AutoFactory
+ ConstructorAnnotated(@Provided Object obj, int i) {}
+
+ @AutoFactory
+ ConstructorAnnotated(@Provided Object obj, char c) {}
}
diff --git a/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java b/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java
index 5bed1e6..1b10e79 100644
--- a/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java
+++ b/factory/src/test/resources/good/ConstructorAnnotatedNonFinal.java
@@ -19,9 +19,17 @@
import com.google.auto.factory.Provided;
final class ConstructorAnnotatedNonFinal {
- @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal() {}
+ @AutoFactory(allowSubclasses = true)
+ ConstructorAnnotatedNonFinal() {}
+
ConstructorAnnotatedNonFinal(Object obj) {}
- @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal(String s) {}
- @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal(@Provided Object obj, int i) {}
- @AutoFactory(allowSubclasses = true) ConstructorAnnotatedNonFinal(@Provided Object obj, char c) {}
+
+ @AutoFactory(allowSubclasses = true)
+ ConstructorAnnotatedNonFinal(String s) {}
+
+ @AutoFactory(allowSubclasses = true)
+ ConstructorAnnotatedNonFinal(@Provided Object obj, int i) {}
+
+ @AutoFactory(allowSubclasses = true)
+ ConstructorAnnotatedNonFinal(@Provided Object obj, char c) {}
}
diff --git a/factory/src/test/resources/good/ConstructorAnnotatedThrows.java b/factory/src/test/resources/good/ConstructorAnnotatedThrows.java
new file mode 100644
index 0000000..58a52d0
--- /dev/null
+++ b/factory/src/test/resources/good/ConstructorAnnotatedThrows.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 tests;
+
+import com.google.auto.factory.AutoFactory;
+import com.google.auto.factory.Provided;
+import java.io.IOException;
+
+final class ConstructorAnnotatedThrows {
+ @AutoFactory
+ ConstructorAnnotatedThrows() throws IOException, InterruptedException {}
+
+ ConstructorAnnotatedThrows(Object obj) {}
+
+ @AutoFactory
+ ConstructorAnnotatedThrows(String s) {}
+
+ @AutoFactory
+ ConstructorAnnotatedThrows(@Provided Object obj, int i) throws IOException {}
+
+ @AutoFactory
+ ConstructorAnnotatedThrows(@Provided Object obj, char c) throws InterruptedException {}
+}
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClass.java b/factory/src/test/resources/good/FactoryExtendingAbstractClass.java
index 5511e99..bd3a4dc 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClass.java
+++ b/factory/src/test/resources/good/FactoryExtendingAbstractClass.java
@@ -20,7 +20,7 @@
@AutoFactory(extending = AbstractFactory.class)
final class FactoryExtendingAbstractClass {
- static abstract class AbstractFactory {
+ abstract static class AbstractFactory {
abstract FactoryExtendingAbstractClass newInstance();
}
}
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java b/factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java
similarity index 63%
copy from factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java
copy to factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java
index 98c5f66..2ac43f3 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java
+++ b/factory/src/test/resources/good/FactoryExtendingAbstractClassThrows.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2013 Google LLC
+ * Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,13 +16,14 @@
package tests;
import com.google.auto.factory.AutoFactory;
-import tests.FactoryExtendingAbstractClassWithConstructorParams.AbstractFactory;
+import java.io.IOException;
+import tests.FactoryExtendingAbstractClassThrows.AbstractFactory;
@AutoFactory(extending = AbstractFactory.class)
-final class FactoryExtendingAbstractClassWithConstructorParams {
- static abstract class AbstractFactory {
- protected AbstractFactory(Object obj) {}
-
- abstract FactoryExtendingAbstractClassWithConstructorParams newInstance();
+final class FactoryExtendingAbstractClassThrows {
+ FactoryExtendingAbstractClassThrows() throws IOException, InterruptedException {}
+
+ abstract static class AbstractFactory {
+ abstract FactoryExtendingAbstractClassThrows newInstance() throws Exception;
}
}
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java b/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java
index 43e94ce..20e0b83 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java
+++ b/factory/src/test/resources/good/FactoryExtendingAbstractClassWithMultipleConstructors.java
@@ -20,10 +20,11 @@
@AutoFactory(extending = AbstractFactory.class)
final class FactoryExtendingAbstractClassWithMultipleConstructors {
- static abstract class AbstractFactory {
+ abstract static class AbstractFactory {
protected AbstractFactory(Object obj) {}
+
protected AbstractFactory() {}
-
+
abstract FactoryExtendingAbstractClassWithMultipleConstructors newInstance();
}
}
diff --git a/factory/src/test/resources/good/FactoryImplementingCreateMethod.java b/factory/src/test/resources/good/FactoryImplementingCreateMethod.java
index db15eef..d265966 100644
--- a/factory/src/test/resources/good/FactoryImplementingCreateMethod.java
+++ b/factory/src/test/resources/good/FactoryImplementingCreateMethod.java
@@ -26,7 +26,7 @@
Interface create();
Interface create(int a);
-
+
Interface create(List<Integer> generic);
}
diff --git a/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java b/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java
index c7435ed..05ee0df 100644
--- a/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java
+++ b/factory/src/test/resources/good/MixedDepsImplementingInterfaces.java
@@ -24,18 +24,18 @@
final class MixedDepsImplementingInterfaces {
@AutoFactory(implementing = {FromInt.class, MarkerA.class})
MixedDepsImplementingInterfaces(@Provided String s, int i) {}
-
+
@AutoFactory(implementing = {FromObject.class, MarkerB.class})
MixedDepsImplementingInterfaces(Object o) {}
interface FromInt {
MixedDepsImplementingInterfaces fromInt(int i);
}
-
+
interface FromObject {
MixedDepsImplementingInterfaces fromObject(Object o);
}
-
+
interface MarkerA {}
interface MarkerB {}
diff --git a/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java b/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java
index 2eecf1a..f7709ec 100644
--- a/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java
+++ b/factory/src/test/resources/good/MultipleFactoriesImplementingInterface.java
@@ -17,7 +17,7 @@
import com.google.auto.factory.AutoFactory;
-class MultipleFactoriesImplementingInterface {
+class MultipleFactoriesImplementingInterface {
static interface Base {
static interface Factory {
public abstract Base abstractNonDefaultCreate();
@@ -25,8 +25,8 @@
}
@AutoFactory(implementing = Base.Factory.class)
- static class ClassA implements Base { }
+ static class ClassA implements Base {}
@AutoFactory(implementing = Base.Factory.class)
static class ClassB implements Base {}
-}
+}
diff --git a/factory/src/test/resources/good/SimpleClassImplementingMarker.java b/factory/src/test/resources/good/SimpleClassImplementingMarker.java
index 24e3abc..52a1fd5 100644
--- a/factory/src/test/resources/good/SimpleClassImplementingMarker.java
+++ b/factory/src/test/resources/good/SimpleClassImplementingMarker.java
@@ -1,11 +1,11 @@
/*
* Copyright 2013 Google LLC
- *
+ *
* 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
@@ -17,5 +17,4 @@
import java.util.RandomAccess;
@AutoFactory(implementing = RandomAccess.class)
-class SimpleClassImplementingMarker {
-}
+class SimpleClassImplementingMarker {}
diff --git a/factory/src/test/resources/good/SimpleClassProvidedDeps.java b/factory/src/test/resources/good/SimpleClassProvidedDeps.java
index ffcefd2..fa9e0c4 100644
--- a/factory/src/test/resources/good/SimpleClassProvidedDeps.java
+++ b/factory/src/test/resources/good/SimpleClassProvidedDeps.java
@@ -1,11 +1,11 @@
/*
* Copyright 2013 Google LLC
- *
+ *
* 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
diff --git a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java b/factory/src/test/resources/good/SimpleClassThrows.java
similarity index 60%
copy from factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java
copy to factory/src/test/resources/good/SimpleClassThrows.java
index 98c5f66..6715595 100644
--- a/factory/src/test/resources/good/FactoryExtendingAbstractClassWithConstructorParams.java
+++ b/factory/src/test/resources/good/SimpleClassThrows.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2013 Google LLC
+ * Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,13 +16,9 @@
package tests;
import com.google.auto.factory.AutoFactory;
-import tests.FactoryExtendingAbstractClassWithConstructorParams.AbstractFactory;
+import java.io.IOException;
-@AutoFactory(extending = AbstractFactory.class)
-final class FactoryExtendingAbstractClassWithConstructorParams {
- static abstract class AbstractFactory {
- protected AbstractFactory(Object obj) {}
-
- abstract FactoryExtendingAbstractClassWithConstructorParams newInstance();
- }
+@AutoFactory
+final class SimpleClassThrows {
+ SimpleClassThrows() throws IOException, InterruptedException {}
}
diff --git a/factory/src/test/resources/support/QualifierWithArgs.java b/factory/src/test/resources/support/QualifierWithArgs.java
index 81e3f84..89f54eb 100644
--- a/factory/src/test/resources/support/QualifierWithArgs.java
+++ b/factory/src/test/resources/support/QualifierWithArgs.java
@@ -29,5 +29,6 @@
@Retention(RUNTIME)
@interface QualifierWithArgs {
String name();
+
int count();
}
diff --git a/service/pom.xml b/service/pom.xml
index a64ca05..e29bdc3 100644
--- a/service/pom.xml
+++ b/service/pom.xml
@@ -37,8 +37,8 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
- <guava.version>27.0.1-jre</guava.version>
- <truth.version>1.0.1</truth.version>
+ <guava.version>30.1.1-jre</guava.version>
+ <truth.version>1.1.3</truth.version>
</properties>
<scm>
@@ -90,7 +90,7 @@
<dependency>
<groupId>com.google.testing.compile</groupId>
<artifactId>compile-testing</artifactId>
- <version>0.18</version>
+ <version>0.19</version>
</dependency>
<dependency>
<groupId>com.google.truth</groupId>
@@ -100,7 +100,7 @@
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
- <version>4.12</version>
+ <version>4.13.2</version>
</dependency>
</dependencies>
</dependencyManagement>
@@ -111,7 +111,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
@@ -123,14 +123,14 @@
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
</plugin>
</plugins>
</pluginManagement>
diff --git a/service/processor/pom.xml b/service/processor/pom.xml
index 22fc20e..262493a 100644
--- a/service/processor/pom.xml
+++ b/service/processor/pom.xml
@@ -49,7 +49,7 @@
<dependency>
<groupId>com.google.auto</groupId>
<artifactId>auto-common</artifactId>
- <version>0.10</version>
+ <version>1.1</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
diff --git a/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java b/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java
index 3bf42d9..f12299a 100644
--- a/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java
+++ b/service/processor/src/main/java/com/google/auto/service/processor/AutoServiceProcessor.java
@@ -17,8 +17,10 @@
import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
import static com.google.auto.common.MoreElements.getAnnotationMirror;
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
+import static com.google.common.base.Throwables.getStackTraceAsString;
+import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.auto.service.AutoService;
import com.google.common.annotations.VisibleForTesting;
@@ -28,8 +30,7 @@
import com.google.common.collect.Sets;
import java.io.IOException;
import java.io.OutputStream;
-import java.io.PrintWriter;
-import java.io.StringWriter;
+import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -57,10 +58,11 @@
* configuration files described in {@link java.util.ServiceLoader}.
* <p>
* Processor Options:<ul>
- * <li>debug - turns on debug statements</li>
+ * <li>{@code -Adebug} - turns on debug statements</li>
+ * <li>{@code -Averify=true} - turns on extra verification</li>
* </ul>
*/
-@SupportedOptions({ "debug", "verify" })
+@SupportedOptions({"debug", "verify"})
public class AutoServiceProcessor extends AbstractProcessor {
@VisibleForTesting
@@ -74,7 +76,7 @@
* {@code "com.google.apphosting.LocalRpcService" ->
* "com.google.apphosting.datastore.LocalDatastoreService"}
*/
- private Multimap<String, String> providers = HashMultimap.create();
+ private final Multimap<String, String> providers = HashMultimap.create();
@Override
public ImmutableSet<String> getSupportedAnnotationTypes() {
@@ -104,28 +106,24 @@
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
try {
- return processImpl(annotations, roundEnv);
- } catch (Exception e) {
+ processImpl(annotations, roundEnv);
+ } catch (RuntimeException e) {
// We don't allow exceptions of any kind to propagate to the compiler
- StringWriter writer = new StringWriter();
- e.printStackTrace(new PrintWriter(writer));
- fatalError(writer.toString());
- return true;
+ fatalError(getStackTraceAsString(e));
}
+ return false;
}
- private boolean processImpl(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+ private void processImpl(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
generateConfigFiles();
} else {
processAnnotations(annotations, roundEnv);
}
-
- return true;
}
- private void processAnnotations(Set<? extends TypeElement> annotations,
- RoundEnvironment roundEnv) {
+ private void processAnnotations(
+ Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(AutoService.class);
@@ -134,7 +132,7 @@
for (Element e : elements) {
// TODO(gak): check for error trees?
- TypeElement providerImplementer = (TypeElement) e;
+ TypeElement providerImplementer = MoreElements.asType(e);
AnnotationMirror annotationMirror = getAnnotationMirror(e, AutoService.class).get();
Set<DeclaredType> providerInterfaces = getValueFieldOfClasses(annotationMirror);
if (providerInterfaces.isEmpty()) {
@@ -147,12 +145,14 @@
log("provider interface: " + providerType.getQualifiedName());
log("provider implementer: " + providerImplementer.getQualifiedName());
- if (checkImplementer(providerImplementer, providerType)) {
+ if (checkImplementer(providerImplementer, providerType, annotationMirror)) {
providers.put(getBinaryName(providerType), getBinaryName(providerImplementer));
} else {
- String message = "ServiceProviders must implement their service provider interface. "
- + providerImplementer.getQualifiedName() + " does not implement "
- + providerType.getQualifiedName();
+ String message =
+ "ServiceProviders must implement their service provider interface. "
+ + providerImplementer.getQualifiedName()
+ + " does not implement "
+ + providerType.getQualifiedName();
error(message, e, annotationMirror);
}
}
@@ -172,8 +172,8 @@
// before we attempt to get the resource in case the behavior
// of filer.getResource does change to match the spec, but there's
// no good way to resolve CLASS_OUTPUT without first getting a resource.
- FileObject existingFile = filer.getResource(StandardLocation.CLASS_OUTPUT, "",
- resourceFile);
+ FileObject existingFile =
+ filer.getResource(StandardLocation.CLASS_OUTPUT, "", resourceFile);
log("Looking for existing resource file at " + existingFile.toUri());
Set<String> oldServices = ServicesFiles.readServiceFile(existingFile.openInputStream());
log("Existing service entries: " + oldServices);
@@ -187,19 +187,18 @@
log("Resource file did not already exist.");
}
- Set<String> newServices = new HashSet<String>(providers.get(providerInterface));
- if (allServices.containsAll(newServices)) {
+ Set<String> newServices = new HashSet<>(providers.get(providerInterface));
+ if (!allServices.addAll(newServices)) {
log("No new service entries being added.");
- return;
+ continue;
}
- allServices.addAll(newServices);
log("New service file contents: " + allServices);
- FileObject fileObject = filer.createResource(StandardLocation.CLASS_OUTPUT, "",
- resourceFile);
- OutputStream out = fileObject.openOutputStream();
- ServicesFiles.writeServiceFile(allServices, out);
- out.close();
+ FileObject fileObject =
+ filer.createResource(StandardLocation.CLASS_OUTPUT, "", resourceFile);
+ try (OutputStream out = fileObject.openOutputStream()) {
+ ServicesFiles.writeServiceFile(allServices, out);
+ }
log("Wrote to: " + fileObject.toUri());
} catch (IOException e) {
fatalError("Unable to create " + resourceFile + ", " + e);
@@ -209,14 +208,17 @@
}
/**
- * Verifies {@link ServiceProvider} constraints on the concrete provider class.
- * Note that these constraints are enforced at runtime via the ServiceLoader,
- * we're just checking them at compile time to be extra nice to our users.
+ * Verifies {@link ServiceProvider} constraints on the concrete provider class. Note that these
+ * constraints are enforced at runtime via the ServiceLoader, we're just checking them at compile
+ * time to be extra nice to our users.
*/
- private boolean checkImplementer(TypeElement providerImplementer, TypeElement providerType) {
+ private boolean checkImplementer(
+ TypeElement providerImplementer,
+ TypeElement providerType,
+ AnnotationMirror annotationMirror) {
String verify = processingEnv.getOptions().get("verify");
- if (verify == null || !Boolean.valueOf(verify)) {
+ if (verify == null || !Boolean.parseBoolean(verify)) {
return true;
}
@@ -225,7 +227,37 @@
Types types = processingEnv.getTypeUtils();
- return types.isSubtype(providerImplementer.asType(), providerType.asType());
+ if (types.isSubtype(providerImplementer.asType(), providerType.asType())) {
+ return true;
+ }
+
+ // Maybe the provider has generic type, but the argument to @AutoService can't be generic.
+ // So we allow that with a warning, which can be suppressed with @SuppressWarnings("rawtypes").
+ // See https://github.com/google/auto/issues/870.
+ if (types.isSubtype(providerImplementer.asType(), types.erasure(providerType.asType()))) {
+ if (!rawTypesSuppressed(providerImplementer)) {
+ warning(
+ "Service provider "
+ + providerType
+ + " is generic, so it can't be named exactly by @AutoService."
+ + " If this is OK, add @SuppressWarnings(\"rawtypes\").",
+ providerImplementer,
+ annotationMirror);
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+ private static boolean rawTypesSuppressed(Element element) {
+ for (; element != null; element = element.getEnclosingElement()) {
+ SuppressWarnings suppress = element.getAnnotation(SuppressWarnings.class);
+ if (suppress != null && Arrays.asList(suppress.value()).contains("rawtypes")) {
+ return true;
+ }
+ }
+ return false;
}
/**
@@ -241,19 +273,20 @@
Element enclosingElement = element.getEnclosingElement();
if (enclosingElement instanceof PackageElement) {
- PackageElement pkg = (PackageElement) enclosingElement;
+ PackageElement pkg = MoreElements.asPackage(enclosingElement);
if (pkg.isUnnamed()) {
return className;
}
return pkg.getQualifiedName() + "." + className;
}
- TypeElement typeElement = (TypeElement) enclosingElement;
+ TypeElement typeElement = MoreElements.asType(enclosingElement);
return getBinaryNameImpl(typeElement, typeElement.getSimpleName() + "$" + className);
}
/**
- * Returns the contents of a {@code Class[]}-typed "value" field in a given {@code annotationMirror}.
+ * Returns the contents of a {@code Class[]}-typed "value" field in a given {@code
+ * annotationMirror}.
*/
private ImmutableSet<DeclaredType> getValueFieldOfClasses(AnnotationMirror annotationMirror) {
return getAnnotationValue(annotationMirror, "value")
@@ -261,16 +294,15 @@
new SimpleAnnotationValueVisitor8<ImmutableSet<DeclaredType>, Void>() {
@Override
public ImmutableSet<DeclaredType> visitType(TypeMirror typeMirror, Void v) {
- // TODO(ronshapiro): class literals may not always be declared types, i.e. int.class,
- // int[].class
+ // TODO(ronshapiro): class literals may not always be declared types, i.e.
+ // int.class, int[].class
return ImmutableSet.of(MoreTypes.asDeclared(typeMirror));
}
@Override
public ImmutableSet<DeclaredType> visitArray(
List<? extends AnnotationValue> values, Void v) {
- return values
- .stream()
+ return values.stream()
.flatMap(value -> value.accept(this, null).stream())
.collect(toImmutableSet());
}
@@ -284,6 +316,10 @@
}
}
+ private void warning(String msg, Element element, AnnotationMirror annotation) {
+ processingEnv.getMessager().printMessage(Kind.WARNING, msg, element, annotation);
+ }
+
private void error(String msg, Element element, AnnotationMirror annotation) {
processingEnv.getMessager().printMessage(Kind.ERROR, msg, element, annotation);
}
diff --git a/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java b/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java
index c61b3ba..75d6cca 100644
--- a/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java
+++ b/service/processor/src/main/java/com/google/auto/service/processor/ServicesFiles.java
@@ -35,7 +35,7 @@
final class ServicesFiles {
public static final String SERVICES_PATH = "META-INF/services";
- private ServicesFiles() { }
+ private ServicesFiles() {}
/**
* Returns an absolute path to a service file given the class
@@ -96,4 +96,4 @@
}
writer.flush();
}
-}
\ No newline at end of file
+}
diff --git a/service/processor/src/main/java/com/google/auto/service/processor/package-info.java b/service/processor/src/main/java/com/google/auto/service/processor/package-info.java
index a9f0adb..453c95e 100644
--- a/service/processor/src/main/java/com/google/auto/service/processor/package-info.java
+++ b/service/processor/src/main/java/com/google/auto/service/processor/package-info.java
@@ -15,4 +15,4 @@
* This package contains the annotation processor that implements the
* {@link com.google.auto.service.AutoService} API.
*/
-package com.google.auto.service.processor;
\ No newline at end of file
+package com.google.auto.service.processor;
diff --git a/service/processor/src/test/java/com/google/auto/service/processor/AutoServiceProcessorTest.java b/service/processor/src/test/java/com/google/auto/service/processor/AutoServiceProcessorTest.java
index d3e00a7..3561568 100644
--- a/service/processor/src/test/java/com/google/auto/service/processor/AutoServiceProcessorTest.java
+++ b/service/processor/src/test/java/com/google/auto/service/processor/AutoServiceProcessorTest.java
@@ -16,52 +16,132 @@
package com.google.auto.service.processor;
import static com.google.auto.service.processor.AutoServiceProcessor.MISSING_SERVICES_ERROR;
-import static com.google.testing.compile.JavaSourcesSubject.assertThat;
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import com.google.common.io.Resources;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.Compiler;
import com.google.testing.compile.JavaFileObjects;
+import javax.tools.StandardLocation;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
-/**
- * Tests the {@link AutoServiceProcessor}.
- */
+/** Tests the {@link AutoServiceProcessor}. */
@RunWith(JUnit4.class)
public class AutoServiceProcessorTest {
@Test
public void autoService() {
- assertThat(
- JavaFileObjects.forResource("test/SomeService.java"),
- JavaFileObjects.forResource("test/SomeServiceProvider1.java"),
- JavaFileObjects.forResource("test/SomeServiceProvider2.java"),
- JavaFileObjects.forResource("test/Enclosing.java"),
- JavaFileObjects.forResource("test/AnotherService.java"),
- JavaFileObjects.forResource("test/AnotherServiceProvider.java"))
- .processedWith(new AutoServiceProcessor())
- .compilesWithoutError()
- .and().generatesFiles(
- JavaFileObjects.forResource("META-INF/services/test.SomeService"),
- JavaFileObjects.forResource("META-INF/services/test.AnotherService"));
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .compile(
+ JavaFileObjects.forResource("test/SomeService.java"),
+ JavaFileObjects.forResource("test/SomeServiceProvider1.java"),
+ JavaFileObjects.forResource("test/SomeServiceProvider2.java"),
+ JavaFileObjects.forResource("test/Enclosing.java"),
+ JavaFileObjects.forResource("test/AnotherService.java"),
+ JavaFileObjects.forResource("test/AnotherServiceProvider.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedFile(StandardLocation.CLASS_OUTPUT, "META-INF/services/test.SomeService")
+ .hasContents(
+ Resources.asByteSource(Resources.getResource("META-INF/services/test.SomeService")));
+ assertThat(compilation)
+ .generatedFile(StandardLocation.CLASS_OUTPUT, "META-INF/services/test.AnotherService")
+ .hasContents(
+ Resources.asByteSource(Resources.getResource("META-INF/services/test.AnotherService")));
}
@Test
public void multiService() {
- assertThat(
- JavaFileObjects.forResource("test/SomeService.java"),
- JavaFileObjects.forResource("test/AnotherService.java"),
- JavaFileObjects.forResource("test/MultiServiceProvider.java"))
- .processedWith(new AutoServiceProcessor())
- .compilesWithoutError()
- .and().generatesFiles(
- JavaFileObjects.forResource("META-INF/services/test.SomeServiceMulti"),
- JavaFileObjects.forResource("META-INF/services/test.AnotherServiceMulti"));
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .compile(
+ JavaFileObjects.forResource("test/SomeService.java"),
+ JavaFileObjects.forResource("test/AnotherService.java"),
+ JavaFileObjects.forResource("test/MultiServiceProvider.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ // We have @AutoService({SomeService.class, AnotherService.class}) class MultiServiceProvider.
+ // So we expect META-INF/services/test.SomeService with contents that name MultiServiceProvider
+ // and likewise META-INF/services/test.AnotherService.
+ assertThat(compilation)
+ .generatedFile(StandardLocation.CLASS_OUTPUT, "META-INF/services/test.SomeService")
+ .contentsAsUtf8String()
+ .isEqualTo("test.MultiServiceProvider\n");
+ assertThat(compilation)
+ .generatedFile(StandardLocation.CLASS_OUTPUT, "META-INF/services/test.AnotherService")
+ .contentsAsUtf8String()
+ .isEqualTo("test.MultiServiceProvider\n");
}
@Test
public void badMultiService() {
- assertThat(JavaFileObjects.forResource("test/NoServices.java"))
- .processedWith(new AutoServiceProcessor())
- .failsToCompile()
- .withErrorContaining(MISSING_SERVICES_ERROR);
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .compile(JavaFileObjects.forResource("test/NoServices.java"));
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorContaining(MISSING_SERVICES_ERROR);
+ }
+
+ @Test
+ public void generic() {
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .compile(
+ JavaFileObjects.forResource("test/GenericService.java"),
+ JavaFileObjects.forResource("test/GenericServiceProvider.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedFile(StandardLocation.CLASS_OUTPUT, "META-INF/services/test.GenericService")
+ .contentsAsUtf8String()
+ .isEqualTo("test.GenericServiceProvider\n");
+ }
+
+ @Test
+ public void genericWithVerifyOption() {
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .withOptions("-Averify=true")
+ .compile(
+ JavaFileObjects.forResource("test/GenericService.java"),
+ JavaFileObjects.forResource("test/GenericServiceProvider.java"));
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .hadWarningContaining(
+ "Service provider test.GenericService is generic, so it can't be named exactly by"
+ + " @AutoService. If this is OK, add @SuppressWarnings(\"rawtypes\").");
+ }
+
+ @Test
+ public void genericWithVerifyOptionAndSuppressWarings() {
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .withOptions("-Averify=true")
+ .compile(
+ JavaFileObjects.forResource("test/GenericService.java"),
+ JavaFileObjects.forResource("test/GenericServiceProviderSuppressWarnings.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ }
+
+ @Test
+ public void nestedGenericWithVerifyOptionAndSuppressWarnings() {
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(new AutoServiceProcessor())
+ .withOptions("-Averify=true")
+ .compile(
+ JavaFileObjects.forResource("test/GenericService.java"),
+ JavaFileObjects.forResource("test/EnclosingGeneric.java"));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedFile(StandardLocation.CLASS_OUTPUT, "META-INF/services/test.GenericService")
+ .contentsAsUtf8String()
+ .isEqualTo("test.EnclosingGeneric$GenericServiceProvider\n");
}
}
diff --git a/service/processor/src/test/resources/META-INF/services/test.AnotherServiceMulti b/service/processor/src/test/resources/META-INF/services/test.AnotherServiceMulti
deleted file mode 100644
index f6ef36a..0000000
--- a/service/processor/src/test/resources/META-INF/services/test.AnotherServiceMulti
+++ /dev/null
@@ -1 +0,0 @@
-test.MultiServiceProvider
diff --git a/service/processor/src/test/resources/META-INF/services/test.SomeServiceMulti b/service/processor/src/test/resources/META-INF/services/test.SomeServiceMulti
deleted file mode 100644
index f6ef36a..0000000
--- a/service/processor/src/test/resources/META-INF/services/test.SomeServiceMulti
+++ /dev/null
@@ -1 +0,0 @@
-test.MultiServiceProvider
diff --git a/service/processor/src/test/resources/test/AnotherService.java b/service/processor/src/test/resources/test/AnotherService.java
index c096c22..de80f06 100644
--- a/service/processor/src/test/resources/test/AnotherService.java
+++ b/service/processor/src/test/resources/test/AnotherService.java
@@ -15,4 +15,4 @@
*/
package test;
-interface AnotherService { }
\ No newline at end of file
+interface AnotherService {}
diff --git a/service/processor/src/test/resources/test/AnotherServiceProvider.java b/service/processor/src/test/resources/test/AnotherServiceProvider.java
index c5e5c11..2a023e4 100644
--- a/service/processor/src/test/resources/test/AnotherServiceProvider.java
+++ b/service/processor/src/test/resources/test/AnotherServiceProvider.java
@@ -18,4 +18,4 @@
import com.google.auto.service.AutoService;
@AutoService(AnotherService.class)
-public class AnotherServiceProvider implements AnotherService { }
\ No newline at end of file
+public class AnotherServiceProvider implements AnotherService {}
diff --git a/service/processor/src/test/resources/test/Enclosing.java b/service/processor/src/test/resources/test/Enclosing.java
index 26dd585..24202a5 100644
--- a/service/processor/src/test/resources/test/Enclosing.java
+++ b/service/processor/src/test/resources/test/Enclosing.java
@@ -19,5 +19,5 @@
public class Enclosing {
@AutoService(SomeService.class)
- public static class NestedSomeServiceProvider implements SomeService { }
-}
\ No newline at end of file
+ public static class NestedSomeServiceProvider implements SomeService {}
+}
diff --git a/service/processor/src/test/resources/test/EnclosingGeneric.java b/service/processor/src/test/resources/test/EnclosingGeneric.java
new file mode 100644
index 0000000..cddddac
--- /dev/null
+++ b/service/processor/src/test/resources/test/EnclosingGeneric.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 test;
+
+import com.google.auto.service.AutoService;
+
+/** Test for suppressing warnings about raw types on nested {@code @AutoService} classes. */
+@SuppressWarnings("rawtypes")
+public final class EnclosingGeneric {
+ /**
+ * This is technically a raw class reference, but should be suppressed by the
+ * {@code @SuppressWarnings} on the enclosing class.
+ */
+ @AutoService(GenericService.class)
+ public class GenericServiceProvider<T> implements GenericService<T> {}
+
+ private EnclosingGeneric() {}
+}
diff --git a/service/processor/src/test/resources/test/GenericService.java b/service/processor/src/test/resources/test/GenericService.java
new file mode 100644
index 0000000..5ed13ff
--- /dev/null
+++ b/service/processor/src/test/resources/test/GenericService.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 test;
+
+/**
+ * An interface with a type parameter, which by default will produce a warning with
+ * {@code @AutoService} if you compile with {@code -Averify=true}.
+ */
+public interface GenericService<T> {}
diff --git a/service/processor/src/test/resources/test/GenericServiceProvider.java b/service/processor/src/test/resources/test/GenericServiceProvider.java
new file mode 100644
index 0000000..84c5cba
--- /dev/null
+++ b/service/processor/src/test/resources/test/GenericServiceProvider.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 test;
+
+import com.google.auto.service.AutoService;
+
+/**
+ * An implementation of a service with a type parameter, which by default will produce a warning
+ * if you compile with {@code -Averify=true}.
+ */
+@AutoService(GenericService.class)
+public class GenericServiceProvider<T> implements GenericService<T> {}
diff --git a/service/processor/src/test/resources/test/GenericServiceProviderSuppressWarnings.java b/service/processor/src/test/resources/test/GenericServiceProviderSuppressWarnings.java
new file mode 100644
index 0000000..eb285da
--- /dev/null
+++ b/service/processor/src/test/resources/test/GenericServiceProviderSuppressWarnings.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * 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 test;
+
+import com.google.auto.service.AutoService;
+
+/**
+ * An implementation of a service with a type parameter, which will not produce a warning even if
+ * compiled with {@code -Averify=true}, because of the {@code @SuppressWarnings}.
+ */
+@AutoService(GenericService.class)
+@SuppressWarnings("rawtypes")
+public class GenericServiceProviderSuppressWarnings<T> implements GenericService<T> {}
diff --git a/service/processor/src/test/resources/test/SomeService.java b/service/processor/src/test/resources/test/SomeService.java
index d29c409..d81cac4 100644
--- a/service/processor/src/test/resources/test/SomeService.java
+++ b/service/processor/src/test/resources/test/SomeService.java
@@ -15,4 +15,4 @@
*/
package test;
-interface SomeService { }
\ No newline at end of file
+interface SomeService {}
diff --git a/service/processor/src/test/resources/test/SomeServiceProvider1.java b/service/processor/src/test/resources/test/SomeServiceProvider1.java
index 008136b..fc2c843 100644
--- a/service/processor/src/test/resources/test/SomeServiceProvider1.java
+++ b/service/processor/src/test/resources/test/SomeServiceProvider1.java
@@ -18,4 +18,4 @@
import com.google.auto.service.AutoService;
@AutoService(SomeService.class)
-public class SomeServiceProvider1 implements SomeService { }
\ No newline at end of file
+public class SomeServiceProvider1 implements SomeService {}
diff --git a/service/processor/src/test/resources/test/SomeServiceProvider2.java b/service/processor/src/test/resources/test/SomeServiceProvider2.java
index 5444996..b7097d4 100644
--- a/service/processor/src/test/resources/test/SomeServiceProvider2.java
+++ b/service/processor/src/test/resources/test/SomeServiceProvider2.java
@@ -18,4 +18,4 @@
import com.google.auto.service.AutoService;
@AutoService(SomeService.class)
-public class SomeServiceProvider2 implements SomeService { }
\ No newline at end of file
+public class SomeServiceProvider2 implements SomeService {}
diff --git a/util/generate-latest-docs.sh b/util/generate-latest-docs.sh
index 8617ba4..88c8e7f 100755
--- a/util/generate-latest-docs.sh
+++ b/util/generate-latest-docs.sh
@@ -1,25 +1,25 @@
-# see http://benlimmer.com/2013/12/26/automatically-publish-javadoc-to-gh-pages-with-travis-ci/ for details
+#!/bin/bash
-if [ "$TRAVIS_REPO_SLUG" == "google/auto" ] && \
- [ "$TRAVIS_JDK_VERSION" == "oraclejdk7" ] && \
- [ "$TRAVIS_PULL_REQUEST" == "false" ] && \
- [ "$TRAVIS_BRANCH" == "master" ]; then
- echo -e "Publishing javadoc...\n"
-
- mvn -f build-pom.xml javadoc:aggregate
- TARGET="$(pwd)/target"
+# Run by GitHub Actions (see .github/workflows/ci.yml)
- cd $HOME
- git clone --quiet --branch=gh-pages https://${GH_TOKEN}@github.com/google/auto gh-pages > /dev/null
-
- cd gh-pages
- git config --global user.email "travis@travis-ci.org"
- git config --global user.name "travis-ci"
- git rm -rf api/latest
- mv ${TARGET}/site/apidocs api/latest
- git add -A -f api/latest
- git commit -m "Latest javadoc on successful travis build $TRAVIS_BUILD_NUMBER auto-pushed to gh-pages"
- git push -fq origin gh-pages > /dev/null
+set -e
- echo -e "Published Javadoc to gh-pages.\n"
-fi
+echo -e "Publishing javadoc...\n"
+
+mvn -f build-pom.xml javadoc:aggregate
+TARGET="$(pwd)/target"
+
+cd $HOME
+git clone --quiet --branch=gh-pages "https://x-access-token:${GITHUB_TOKEN}@github.com/google/auto" gh-pages > /dev/null
+
+cd gh-pages
+git config --global user.name "$GITHUB_ACTOR"
+git config --global user.email "$GITHUB_ACTOR@users.noreply.github.com"
+git rm -rf api/latest
+mkdir -p api # Just to make mv work if the directory is missing
+mv ${TARGET}/site/apidocs api/latest
+git add -A -f api/latest
+git commit -m "Latest javadoc on successful CI build auto-pushed to gh-pages"
+git push -fq origin gh-pages > /dev/null
+
+echo -e "Published Javadoc to gh-pages.\n"
diff --git a/util/publish-snapshot-on-commit.sh b/util/publish-snapshot-on-commit.sh
index 0b74c6b..0166b05 100755
--- a/util/publish-snapshot-on-commit.sh
+++ b/util/publish-snapshot-on-commit.sh
@@ -1,12 +1,6 @@
-# see https://coderwall.com/p/9b_lfq
+#!/bin/bash
-if [ "$TRAVIS_REPO_SLUG" == "google/auto" ] && \
- [ "$TRAVIS_JDK_VERSION" == "oraclejdk7" ] && \
- [ "$TRAVIS_PULL_REQUEST" == "false" ] && \
- [ "$TRAVIS_BRANCH" == "master" ]; then
- echo -e "Publishing maven snapshot...\n"
+set -e
- mvn -f build-pom.xml clean source:jar deploy --settings="util/settings.xml" -DskipTests=true -Dmaven.javadoc.skip=true
-
- echo -e "Published maven snapshot"
-fi
+mvn -B dependency:go-offline test clean -U --quiet --fail-never -DskipTests=true -f build-pom.xml
+mvn -B -U source:jar deploy -DskipTests=true -f build-pom.xml
diff --git a/util/settings.xml b/util/settings.xml
deleted file mode 100644
index 91f444b..0000000
--- a/util/settings.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<settings>
- <servers>
- <server>
- <id>sonatype-nexus-snapshots</id>
- <username>${env.CI_DEPLOY_USERNAME}</username>
- <password>${env.CI_DEPLOY_PASSWORD}</password>
- </server>
- </servers>
-</settings>
diff --git a/value/Android.bp b/value/Android.bp
index 73a7215..2f554aa 100644
--- a/value/Android.bp
+++ b/value/Android.bp
@@ -72,6 +72,23 @@
}
java_plugin {
+ name: "auto_oneof_plugin",
+ static_libs: [
+ "libauto_value_plugin",
+
+ "auto_android_annotation_stubs",
+ "auto_common",
+ "auto_service_plugin",
+ "auto_value_extension",
+ "escapevelocity",
+ "guava",
+ "javapoet",
+ ],
+ processor_class: "com.google.auto.value.processor.AutoOneOfProcessor",
+ visibility: ["//visibility:public"],
+}
+
+java_plugin {
name: "auto_annotation_plugin",
static_libs: [
"libauto_value_plugin",
diff --git a/value/annotations/pom.xml b/value/annotations/pom.xml
index d6c03de..8bc63ac 100644
--- a/value/annotations/pom.xml
+++ b/value/annotations/pom.xml
@@ -54,6 +54,7 @@
<include>com/google/auto/value/*</include>
<include>com/google/auto/value/extension/memoized/*</include>
<include>com/google/auto/value/extension/serializable/*</include>
+ <include>com/google/auto/value/extension/toprettystring/*</include>
</includes>
</configuration>
</plugin>
diff --git a/value/pom.xml b/value/pom.xml
index dcf2cb1..5405c7c 100644
--- a/value/pom.xml
+++ b/value/pom.xml
@@ -37,8 +37,8 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
- <guava.version>28.1-jre</guava.version>
- <truth.version>1.0.1</truth.version>
+ <guava.version>30.1.1-jre</guava.version>
+ <truth.version>1.1.3</truth.version>
</properties>
<scm>
@@ -89,7 +89,7 @@
<dependency>
<groupId>com.squareup</groupId>
<artifactId>javapoet</artifactId>
- <version>1.11.1</version>
+ <version>1.13.0</version>
</dependency>
<!-- test dependencies -->
@@ -107,7 +107,7 @@
<dependency>
<groupId>com.google.testing.compile</groupId>
<artifactId>compile-testing</artifactId>
- <version>0.18</version>
+ <version>0.19</version>
</dependency>
<dependency>
<groupId>com.google.truth</groupId>
@@ -122,7 +122,7 @@
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
- <version>4.13</version>
+ <version>4.13.2</version>
</dependency>
<dependency>
<groupId>org.apache.velocity</groupId>
@@ -138,7 +138,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
@@ -150,19 +150,19 @@
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-invoker-plugin</artifactId>
- <version>3.0.1</version>
+ <version>3.2.2</version>
<configuration>
<addTestClassPath>true</addTestClassPath>
<cloneProjectsTo>${project.build.directory}/it</cloneProjectsTo>
diff --git a/value/processor/pom.xml b/value/processor/pom.xml
index 5968352..8892c4f 100644
--- a/value/processor/pom.xml
+++ b/value/processor/pom.xml
@@ -40,23 +40,26 @@
<tag>HEAD</tag>
</scm>
+ <properties>
+ <auto-service.version>1.0</auto-service.version>
+ <errorprone.version>2.7.1</errorprone.version>
+ </properties>
+
<dependencies>
<dependency>
<groupId>com.google.auto</groupId>
<artifactId>auto-common</artifactId>
- <version>0.10</version>
+ <version>1.1</version>
</dependency>
<dependency>
<groupId>com.google.auto.service</groupId>
- <artifactId>auto-service</artifactId>
- <version>1.0-rc6</version>
- <scope>provided</scope>
+ <artifactId>auto-service-annotations</artifactId>
+ <version>${auto-service.version}</version>
</dependency>
<dependency>
<groupId>com.google.errorprone</groupId>
<artifactId>error_prone_annotations</artifactId>
- <version>2.3.3</version>
- <scope>provided</scope>
+ <version>${errorprone.version}</version>
</dependency>
<dependency>
<groupId>com.google.escapevelocity</groupId>
@@ -66,13 +69,7 @@
<dependency>
<groupId>net.ltgt.gradle.incap</groupId>
<artifactId>incap</artifactId>
- <version>0.2</version>
- </dependency>
- <dependency>
- <groupId>net.ltgt.gradle.incap</groupId>
- <artifactId>incap-processor</artifactId>
- <version>0.2</version>
- <scope>provided</scope>
+ <version>0.3</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
@@ -90,6 +87,12 @@
<scope>test</scope>
</dependency>
<dependency>
+ <groupId>com.google.errorprone</groupId>
+ <artifactId>error_prone_type_annotations</artifactId>
+ <version>${errorprone.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<scope>test</scope>
@@ -122,7 +125,7 @@
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
- <version>3.1.0</version>
+ <version>3.11.2</version>
<scope>test</scope>
</dependency>
</dependencies>
@@ -149,7 +152,55 @@
<include>com/google/auto/value/extension/memoized/processor/**/*.java</include>
<include>com/google/auto/value/extension/serializable/processor/**/*.java</include>
<include>com/google/auto/value/extension/serializable/serializer/**/*.java</include>
+ <include>com/google/auto/value/extension/toprettystring/processor/**/*.java</include>
</includes>
+ <compilerArgs>
+ <!-- This is something of a hack to allow tests to pass. Ideally we would build
+ TestStringSerializerFactory as a separate artifact, to avoid a problem when it
+ is built at the same time as @AutoValue classes that might end up finding it.
+ But by allowing a missing class to be ignored, we avoid crashing if there is a
+ META-INF/services entry for a class that the compiler has not yet generated. -->
+ <arg>-AallowedMissingSerializableExtensionClasses=.*TestStringSerializerFactory</arg>
+ </compilerArgs>
+ <annotationProcessorPaths>
+ <path>
+ <groupId>com.google.auto.service</groupId>
+ <artifactId>auto-service</artifactId>
+ <version>${auto-service.version}</version>
+ </path>
+ <path>
+ <groupId>net.ltgt.gradle.incap</groupId>
+ <artifactId>incap-processor</artifactId>
+ <version>0.3</version>
+ </path>
+ </annotationProcessorPaths>
+ </configuration>
+ <executions>
+ <execution>
+ <id>default-testCompile</id>
+ <configuration>
+ <annotationProcessorPaths>
+ <path>
+ <groupId>com.google.auto.value</groupId>
+ <artifactId>auto-value</artifactId>
+ <version>${project.version}</version>
+ </path>
+ <path>
+ <groupId>com.google.auto.service</groupId>
+ <artifactId>auto-service</artifactId>
+ <version>${auto-service.version}</version>
+ </path>
+ </annotationProcessorPaths>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <version>2.22.2</version>
+ <configuration>
+ <argLine>${test.jvm.flags}</argLine>
</configuration>
</plugin>
<plugin>
@@ -217,5 +268,14 @@
<additionalparam>-Xdoclint:none</additionalparam>
</properties>
</profile>
+ <profile>
+ <id>open-modules</id>
+ <activation>
+ <jdk>[9,)</jdk>
+ </activation>
+ <properties>
+ <test.jvm.flags>--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</test.jvm.flags>
+ </properties>
+ </profile>
</profiles>
</project>
diff --git a/value/src/it/functional/pom.xml b/value/src/it/functional/pom.xml
index 750b9c4..d4ae138 100644
--- a/value/src/it/functional/pom.xml
+++ b/value/src/it/functional/pom.xml
@@ -32,6 +32,7 @@
<version>1.7.4</version>
<name>Auto-Value Functional Integration Test</name>
<properties>
+ <kotlin.version>1.5.21</kotlin.version>
<exclude.tests>this-matches-nothing</exclude.tests>
</properties>
<dependencies>
@@ -48,7 +49,7 @@
<dependency>
<groupId>com.google.auto.service</groupId>
<artifactId>auto-service</artifactId>
- <version>1.0-rc6</version>
+ <version>1.0</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
@@ -62,7 +63,7 @@
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-user</artifactId>
- <version>2.8.2</version>
+ <version>2.9.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
@@ -90,21 +91,32 @@
<scope>test</scope>
</dependency>
<dependency>
+ <groupId>dev.gradleplugins</groupId>
+ <artifactId>gradle-test-kit</artifactId>
+ <version>6.8.3</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
- <version>3.1.0</version>
+ <version>3.11.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.eclipse.jdt</groupId>
<artifactId>ecj</artifactId>
- <version>3.20.0</version>
+ <version>3.25.0</version>
</dependency>
<dependency>
<groupId>com.google.escapevelocity</groupId>
<artifactId>escapevelocity</artifactId>
<version>0.9.1</version>
</dependency>
+ <dependency>
+ <groupId>org.jetbrains.kotlin</groupId>
+ <artifactId>kotlin-stdlib</artifactId>
+ <version>${kotlin.version}</version>
+ </dependency>
</dependencies>
<build>
@@ -112,17 +124,49 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
+ </plugin>
+ <plugin>
+ <groupId>org.jetbrains.kotlin</groupId>
+ <artifactId>kotlin-maven-plugin</artifactId>
+ <version>${kotlin.version}</version>
+ <executions>
+ <!--
+ The Kotlin configuration here is a bit unusual. JetBrains recommends
+ <https://kotlinlang.org/docs/maven.html#compile-kotlin-and-java-sources>
+ a fairly invasive reconfiguration of the maven-compiler-plugin (which compiles Java)
+ in order to ensure that the Kotlin compiler can run first. In our case, we have just
+ one Kotlin file that a test in Java accesses. So, even though it is in src/test/java,
+ we compile it in the `compile` goal, which means it is available to the Java test sources
+ when they are compiled in the `default-testCompile` goal.
+
+ Currently if you want to use JDK ≥ 16 then you must set
+ JAVA_TOOL_OPTIONS=__illegal-access=permit
+ except the two underscores should be dashes (which XML comments won't allow us to write).
+ This is a bug that will presumably be fixed in a forthcoming version.
+ -->
+ <execution>
+ <id>compile</id>
+ <goals>
+ <goal>compile</goal>
+ </goals>
+ <configuration>
+ <sourceDirs>
+ <sourceDir>${project.basedir}/src/test/java</sourceDir>
+ </sourceDirs>
+ </configuration>
+ </execution>
+ </executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<dependencies>
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
<configuration>
@@ -132,6 +176,7 @@
<arg>-Xlint:all</arg>
<arg>-encoding</arg>
<arg>utf8</arg>
+ <arg>-Acom.google.auto.value.AutoBuilderIsUnstable</arg>
</compilerArgs>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
@@ -143,12 +188,23 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-deploy-plugin</artifactId>
- <version>2.7</version>
+ <version>2.8.2</version>
<configuration>
<!-- Build/test, but don't deploy -->
<skip>true</skip>
</configuration>
</plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <version>2.22.2</version>
+ <configuration>
+ <argLine>${test.jvm.flags}</argLine>
+ <systemPropertyVariables>
+ <autoValueVersion>${project.version}</autoValueVersion>
+ </systemPropertyVariables>
+ </configuration>
+ </plugin>
</plugins>
</build>
@@ -160,12 +216,12 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<dependencies>
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
<configuration>
@@ -195,5 +251,27 @@
<exclude.tests>**/AutoValueJava8Test.java</exclude.tests>
</properties>
</profile>
+ <profile>
+ <id>open-modules</id>
+ <activation>
+ <jdk>[9,)</jdk>
+ </activation>
+ <properties>
+ <test.jvm.flags>--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</test.jvm.flags>
+ </properties>
+ </profile>
+ <profile>
+ <!-- Before JDK 11, parameter names from already-compiled classes are not reliably available
+ to the compiler even when they are present in class files. Since our Kotlin test file
+ obviously has to be compiled separately from the Java test that uses it,
+ AutoBuilderKotlinTest doesn't pass on earlier JDK versions. -->
+ <id>exclude-separate-compilation-parameter-names</id>
+ <activation>
+ <jdk>(,11)</jdk>
+ </activation>
+ <properties>
+ <exclude.tests>**/AutoBuilderKotlinTest.java</exclude.tests>
+ </properties>
+ </profile>
</profiles>
</project>
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoAnnotationTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoAnnotationTest.java
index ca1ef6b..a04d41f 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoAnnotationTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoAnnotationTest.java
@@ -15,20 +15,24 @@
*/
package com.google.auto.value;
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
import com.google.auto.value.annotations.Empty;
import com.google.auto.value.annotations.GwtArrays;
import com.google.auto.value.annotations.StringValues;
+import com.google.common.base.StandardSystemProperty;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
-import com.google.common.primitives.Ints;
import com.google.common.testing.EqualsTester;
+import com.google.common.testing.SerializableTester;
+import java.io.ObjectStreamClass;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -38,6 +42,7 @@
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
+import org.junit.AssumptionViolatedException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -66,13 +71,41 @@
}
@Test
+ public void testEqualsParameterAnnotation() throws ReflectiveOperationException {
+ assume()
+ .that(Double.parseDouble(StandardSystemProperty.JAVA_SPECIFICATION_VERSION.value()))
+ .isAtLeast(8.0);
+ Class<? extends Annotation> jspecifyNullable;
+ try {
+ // We write this using .concat in order to hide it from rewriting rules.
+ jspecifyNullable =
+ Class.forName("org".concat(".jspecify.nullness.Nullable")).asSubclass(Annotation.class);
+ } catch (ClassNotFoundException e) {
+ throw new AssumptionViolatedException("No JSpecify @Nullable available", e);
+ }
+ @SuppressWarnings("GetClassOnAnnotation") // yes, I really want the implementation class
+ Class<? extends StringValues> autoAnnotationImpl = newStringValues(new String[0]).getClass();
+ Method equals = autoAnnotationImpl.getDeclaredMethod("equals", Object.class);
+ // The remaining faffing around with reflection is there because we have a Google-internal test
+ // that runs this code with -source 7 -target 7. We're really just doing this:
+ // assertThat(equals.getAnnotatedParameterTypes()[0].isAnnotationPresent(jspecifyNullable))
+ // .isTrue();
+ Method getAnnotatedParameterTypes = Method.class.getMethod("getAnnotatedParameterTypes");
+ Object[] annotatedParameterTypes = (Object[]) getAnnotatedParameterTypes.invoke(equals);
+ Method isAnnotationPresent =
+ annotatedParameterTypes[0].getClass().getMethod("isAnnotationPresent", Class.class);
+ assertThat(isAnnotationPresent.invoke(annotatedParameterTypes[0], jspecifyNullable))
+ .isEqualTo(true);
+ }
+
+ @Test
public void testArraysAreCloned() {
String[] array = {"Jekyll"};
StringValues stringValues = newStringValues(array);
array[0] = "Hyde";
- assertEquals("Jekyll", stringValues.value()[0]);
+ assertThat(stringValues.value()).asList().containsExactly("Jekyll");
stringValues.value()[0] = "Hyde";
- assertEquals("Jekyll", stringValues.value()[0]);
+ assertThat(stringValues.value()[0]).isEqualTo("Jekyll");
}
@Test
@@ -80,12 +113,12 @@
String[] strings = {"Jekyll"};
int[] ints = {2, 3, 5};
GwtArrays arrays = newGwtArrays(strings, ints);
- assertEquals(ImmutableList.of("Jekyll"), ImmutableList.copyOf(arrays.strings()));
- assertEquals(ImmutableList.of(2, 3, 5), Ints.asList(arrays.ints()));
+ assertThat(arrays.strings()).asList().containsExactly("Jekyll");
+ assertThat(arrays.ints()).asList().containsExactly(2, 3, 5).inOrder();
strings[0] = "Hyde";
ints[0] = -1;
- assertEquals(ImmutableList.of("Jekyll"), ImmutableList.copyOf(arrays.strings()));
- assertEquals(ImmutableList.of(2, 3, 5), Ints.asList(arrays.ints()));
+ assertThat(arrays.strings()).asList().containsExactly("Jekyll");
+ assertThat(arrays.ints()).asList().containsExactly(2, 3, 5).inOrder();
}
@AutoAnnotation
@@ -406,7 +439,39 @@
.testEquals();
}
+ @Test
+ public void testSerialization() {
+ Annotation[] instances = {EVERYTHING_FROM_AUTO, EVERYTHING_FROM_AUTO_COLLECTIONS};
+ for (Annotation instance : instances) {
+ SerializableTester.reserializeAndAssert(instance);
+ }
+ }
+
+ @Test
+ @SuppressWarnings("GetClassOnAnnotation") // yes, we really do want the implementation classes
+ public void testSerialVersionUid() {
+ Class<? extends Everything> everythingImpl = EVERYTHING_FROM_AUTO.getClass();
+ Class<? extends Everything> everythingFromCollectionsImpl =
+ EVERYTHING_FROM_AUTO_COLLECTIONS.getClass();
+ assertThat(everythingImpl).isNotEqualTo(everythingFromCollectionsImpl);
+ long everythingUid = ObjectStreamClass.lookup(everythingImpl).getSerialVersionUID();
+ long everythingFromCollectionsUid =
+ ObjectStreamClass.lookup(everythingFromCollectionsImpl).getSerialVersionUID();
+ // Two different implementations of the same annotation with the same members being provided
+ // (not defaulted) should have the same serialVersionUID. They won't be serial-compatible, of
+ // course, because their classes are different. So we're really just checking that the
+ // serialVersionUID depends only on the names and types of those members.
+ assertThat(everythingFromCollectionsUid).isEqualTo(everythingUid);
+ Class<? extends StringValues> stringValuesImpl = newStringValues(new String[0]).getClass();
+ long stringValuesUid = ObjectStreamClass.lookup(stringValuesImpl).getSerialVersionUID();
+ // The previous assertion would be vacuously true if every implementation had the same
+ // serialVersionUID, so check that that's not true.
+ assertThat(stringValuesUid).isNotEqualTo(everythingUid);
+ }
+
public static class IntList extends ArrayList<Integer> {
+ private static final long serialVersionUID = 1L;
+
IntList(Collection<Integer> c) {
super(c);
}
@@ -440,7 +505,7 @@
IntList intList = new IntList(ImmutableList.of(1, 2, 3));
IntArray actual = newIntArray(intList);
IntArray expected = AnnotatedWithIntArray.class.getAnnotation(IntArray.class);
- assertEquals(expected, actual);
+ assertThat(actual).isEqualTo(expected);
}
@Test
@@ -461,8 +526,8 @@
+ "@com.google.auto.value.annotations.StringValues([\"foo\", \"bar\"])"
+ "]"
+ ")";
- assertEquals(expected, EVERYTHING_FROM_AUTO.toString());
- assertEquals(expected, EVERYTHING_FROM_AUTO_COLLECTIONS.toString());
+ assertThat(EVERYTHING_FROM_AUTO.toString()).isEqualTo(expected);
+ assertThat(EVERYTHING_FROM_AUTO_COLLECTIONS.toString()).isEqualTo(expected);
}
@Test
@@ -475,7 +540,7 @@
String expected =
"@com.google.auto.value.annotations.StringValues("
+ "[\"\", \"\\r\\n\", \"hello, world\", \"Éamonn\", \"\\007\\uffef\"])";
- assertEquals(expected, instance.toString());
+ assertThat(instance.toString()).isEqualTo(expected);
}
@Retention(RetentionPolicy.RUNTIME)
@@ -498,7 +563,7 @@
ImmutableList.<Class<? extends Annotation>>of(AnnotationsAnnotation.class));
AnnotationsAnnotation fromReflect =
AnnotatedWithAnnotationsAnnotation.class.getAnnotation(AnnotationsAnnotation.class);
- assertEquals(fromReflect, generated);
+ assertThat(generated).isEqualTo(fromReflect);
}
@Retention(RetentionPolicy.RUNTIME)
@@ -520,7 +585,7 @@
newClassesAnnotation(Arrays.<Class<?>>asList(AnnotationsAnnotation.class));
ClassesAnnotation fromReflect =
AnnotatedWithClassesAnnotation.class.getAnnotation(ClassesAnnotation.class);
- assertEquals(fromReflect, generated);
+ assertThat(generated).isEqualTo(fromReflect);
}
@Retention(RetentionPolicy.RUNTIME)
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderKotlinTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderKotlinTest.java
new file mode 100644
index 0000000..1dc346c
--- /dev/null
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderKotlinTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AutoBuilderKotlinTest {
+ @AutoBuilder(ofClass = KotlinData.class)
+ abstract static class KotlinDataBuilder {
+ static KotlinDataBuilder builder() {
+ return new AutoBuilder_AutoBuilderKotlinTest_KotlinDataBuilder();
+ }
+
+ abstract KotlinDataBuilder setInt(int x);
+
+ abstract KotlinDataBuilder setString(String x);
+
+ abstract KotlinData build();
+ }
+
+ @Test
+ public void simpleKotlin() {
+ KotlinData x = KotlinDataBuilder.builder().setInt(23).setString("skidoo").build();
+ assertThat(x.getInt()).isEqualTo(23);
+ assertThat(x.getString()).isEqualTo("skidoo");
+ }
+
+ @AutoBuilder(ofClass = KotlinDataWithNullable.class)
+ abstract static class KotlinDataWithNullableBuilder {
+ static KotlinDataWithNullableBuilder builder() {
+ return new AutoBuilder_AutoBuilderKotlinTest_KotlinDataWithNullableBuilder();
+ }
+
+ abstract KotlinDataWithNullableBuilder setAnInt(int x);
+
+ abstract KotlinDataWithNullableBuilder setAString(String x);
+
+ abstract KotlinDataWithNullable build();
+ }
+
+ @Test
+ public void kotlinWithNullable() {
+ KotlinDataWithNullable empty = KotlinDataWithNullableBuilder.builder().build();
+ assertThat(empty.getAnInt()).isNull();
+ assertThat(empty.getAString()).isNull();
+
+ KotlinDataWithNullable notEmpty =
+ KotlinDataWithNullableBuilder.builder().setAString("answer").setAnInt(42).build();
+ assertThat(notEmpty.getAString()).isEqualTo("answer");
+ assertThat(notEmpty.getAnInt()).isEqualTo(42);
+ }
+
+ @AutoBuilder(ofClass = KotlinDataWithDefaults.class)
+ abstract static class KotlinDataWithDefaultsBuilder {
+ static KotlinDataWithDefaultsBuilder builder() {
+ return new AutoBuilder_AutoBuilderKotlinTest_KotlinDataWithDefaultsBuilder();
+ }
+
+ abstract KotlinDataWithDefaultsBuilder setAnInt(int x);
+
+ abstract KotlinDataWithDefaultsBuilder setAString(String x);
+
+ abstract KotlinDataWithDefaults build();
+ }
+
+ @Test
+ public void kotlinWithDefaults() {
+ // AutoBuilder doesn't currently try to give the builder the same defaults as the Kotlin class,
+ // but we do at least check that the presence of defaults doesn't throw AutoBuilder off.
+ // When a constructor has default parameters, the Kotlin compiler generates an extra constructor
+ // with two extra parameters: an int bitmask saying which parameters were defaulted, and a
+ // DefaultConstructorMarker parameter to avoid clashing with another constructor that might have
+ // an extra int parameter for some other reason. If AutoBuilder found this constructor it might
+ // be confused, but fortunately the constructor is marked synthetic, and javax.lang.model
+ // doesn't show synthetic elements.
+ KotlinDataWithDefaults x =
+ KotlinDataWithDefaultsBuilder.builder().setAString("answer").setAnInt(42).build();
+ assertThat(x.getAString()).isEqualTo("answer");
+ assertThat(x.getAnInt()).isEqualTo(42);
+ }
+}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java
new file mode 100644
index 0000000..952edaa
--- /dev/null
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java
@@ -0,0 +1,580 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth8.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.time.LocalTime;
+import java.util.AbstractSet;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AutoBuilderTest {
+ static class Simple {
+ private final int anInt;
+ private final String aString;
+
+ Simple(int anInt, String aString) {
+ this.anInt = anInt;
+ this.aString = aString;
+ }
+
+ static Simple of(int anInt, String aString) {
+ return new Simple(anInt, aString);
+ }
+
+ @Override
+ public boolean equals(Object x) {
+ if (x instanceof Simple) {
+ Simple that = (Simple) x;
+ return this.anInt == that.anInt && Objects.equals(this.aString, that.aString);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(anInt, aString);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this)
+ .add("anInt", anInt)
+ .add("aString", aString)
+ .toString();
+ }
+
+ static Builder builder() {
+ return new AutoBuilder_AutoBuilderTest_Simple_Builder();
+ }
+
+ @AutoBuilder
+ abstract static class Builder {
+ abstract Builder setAnInt(int x);
+
+ abstract Builder setAString(String x);
+
+ abstract Simple build();
+ }
+ }
+
+ @Test
+ public void simple() {
+ Simple x = Simple.builder().setAnInt(23).setAString("skidoo").build();
+ assertThat(x).isEqualTo(new Simple(23, "skidoo"));
+ }
+
+ @AutoValue
+ abstract static class SimpleAuto {
+ abstract int getFoo();
+
+ abstract String getBar();
+
+ static Builder builder() {
+ return new AutoBuilder_AutoBuilderTest_SimpleAuto_Builder();
+ }
+
+ // There's no particular reason to do this since @AutoValue.Builder works just as well, but
+ // let's check anyway.
+ @AutoBuilder(ofClass = AutoValue_AutoBuilderTest_SimpleAuto.class)
+ abstract static class Builder {
+ abstract Builder setFoo(int x);
+
+ abstract Builder setBar(String x);
+
+ abstract AutoValue_AutoBuilderTest_SimpleAuto build();
+ }
+ }
+
+ @Test
+ public void simpleAuto() {
+ SimpleAuto x = SimpleAuto.builder().setFoo(23).setBar("skidoo").build();
+ assertThat(x.getFoo()).isEqualTo(23);
+ assertThat(x.getBar()).isEqualTo("skidoo");
+ }
+
+ enum Truthiness {
+ FALSY,
+ TRUTHY
+ }
+
+ @interface MyAnnotation {
+ String value();
+
+ int DEFAULT_ID = -1;
+
+ int id() default DEFAULT_ID;
+
+ Truthiness DEFAULT_TRUTHINESS = Truthiness.FALSY;
+
+ Truthiness truthiness() default Truthiness.FALSY;
+ }
+
+ // This method has a parameter for `truthiness`, even though that has a default, but it has no
+ // parameter for `id`, which also has a default.
+ @AutoAnnotation
+ static MyAnnotation myAnnotation(String value, Truthiness truthiness) {
+ return new AutoAnnotation_AutoBuilderTest_myAnnotation(value, truthiness);
+ }
+
+ @AutoBuilder(callMethod = "myAnnotation")
+ interface MyAnnotationBuilder {
+ MyAnnotationBuilder value(String x);
+
+ MyAnnotationBuilder truthiness(Truthiness x);
+
+ MyAnnotation build();
+ }
+
+ static MyAnnotationBuilder myAnnotationBuilder() {
+ return new AutoBuilder_AutoBuilderTest_MyAnnotationBuilder()
+ .truthiness(MyAnnotation.DEFAULT_TRUTHINESS);
+ }
+
+ @Test
+ public void simpleAutoAnnotation() {
+ MyAnnotation annotation1 = myAnnotationBuilder().value("foo").build();
+ assertThat(annotation1.value()).isEqualTo("foo");
+ assertThat(annotation1.id()).isEqualTo(MyAnnotation.DEFAULT_ID);
+ assertThat(annotation1.truthiness()).isEqualTo(MyAnnotation.DEFAULT_TRUTHINESS);
+ MyAnnotation annotation2 =
+ myAnnotationBuilder().value("bar").truthiness(Truthiness.TRUTHY).build();
+ assertThat(annotation2.value()).isEqualTo("bar");
+ assertThat(annotation2.id()).isEqualTo(MyAnnotation.DEFAULT_ID);
+ assertThat(annotation2.truthiness()).isEqualTo(Truthiness.TRUTHY);
+ }
+
+ static class Overload {
+ final int anInt;
+ final String aString;
+ final BigInteger aBigInteger;
+
+ Overload(int anInt, String aString) {
+ this(anInt, aString, BigInteger.ZERO);
+ }
+
+ Overload(int anInt, String aString, BigInteger aBigInteger) {
+ this.anInt = anInt;
+ this.aString = aString;
+ this.aBigInteger = aBigInteger;
+ }
+
+ @Override
+ public boolean equals(Object x) {
+ if (x instanceof Overload) {
+ Overload that = (Overload) x;
+ return this.anInt == that.anInt
+ && Objects.equals(this.aString, that.aString)
+ && Objects.equals(this.aBigInteger, that.aBigInteger);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(anInt, aString, aBigInteger);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this)
+ .add("anInt", anInt)
+ .add("aString", aString)
+ .add("aBigInteger", aBigInteger)
+ .toString();
+ }
+
+ static Builder1 builder1() {
+ return new AutoBuilder_AutoBuilderTest_Overload_Builder1();
+ }
+
+ static Builder2 builder2() {
+ return new AutoBuilder_AutoBuilderTest_Overload_Builder2();
+ }
+
+ @AutoBuilder
+ interface Builder1 {
+ Builder1 setAnInt(int x);
+
+ Builder1 setAString(String x);
+
+ Overload build();
+ }
+
+ @AutoBuilder
+ interface Builder2 {
+ Builder2 setAnInt(int x);
+
+ Builder2 setAString(String x);
+
+ Builder2 setABigInteger(BigInteger x);
+
+ Overload build();
+ }
+ }
+
+ @Test
+ public void overloadedConstructor() {
+ Overload actual1 = Overload.builder1().setAnInt(23).setAString("skidoo").build();
+ Overload expected1 = new Overload(23, "skidoo");
+ assertThat(actual1).isEqualTo(expected1);
+
+ BigInteger big17 = BigInteger.valueOf(17);
+ Overload actual2 =
+ Overload.builder2().setAnInt(17).setAString("17").setABigInteger(big17).build();
+ Overload expected2 = new Overload(17, "17", big17);
+ assertThat(actual2).isEqualTo(expected2);
+ }
+
+ @AutoBuilder(callMethod = "of", ofClass = Simple.class)
+ interface SimpleStaticBuilder {
+ SimpleStaticBuilder anInt(int x);
+
+ SimpleStaticBuilder aString(String x);
+
+ Simple build();
+ }
+
+ static SimpleStaticBuilder simpleStaticBuilder() {
+ return new AutoBuilder_AutoBuilderTest_SimpleStaticBuilder();
+ }
+
+ @Test
+ public void staticMethod() {
+ Simple actual = simpleStaticBuilder().anInt(17).aString("17").build();
+ Simple expected = new Simple(17, "17");
+ assertThat(actual).isEqualTo(expected);
+ }
+
+ // We can't be sure that the java.time package has parameter names, so we use this intermediary.
+ // Otherwise we could just write @AutoBuilder(callMethod = "of", ofClass = LocalTime.class).
+ // It's still interesting to test this as a realistic example.
+ static LocalTime localTimeOf(int hour, int minute, int second, int nanoOfSecond) {
+ return LocalTime.of(hour, minute, second, nanoOfSecond);
+ }
+
+ static LocalTimeBuilder localTimeBuilder() {
+ return new AutoBuilder_AutoBuilderTest_LocalTimeBuilder().nanoOfSecond(0);
+ }
+
+ @AutoBuilder(callMethod = "localTimeOf")
+ interface LocalTimeBuilder {
+ LocalTimeBuilder hour(int hour);
+
+ LocalTimeBuilder minute(int minute);
+
+ LocalTimeBuilder second(int second);
+
+ LocalTimeBuilder nanoOfSecond(int nanoOfSecond);
+
+ LocalTime build();
+ }
+
+ @Test
+ public void staticMethodOfContainingClass() {
+ LocalTime actual = localTimeBuilder().hour(12).minute(34).second(56).build();
+ LocalTime expected = LocalTime.of(12, 34, 56);
+ assertThat(actual).isEqualTo(expected);
+ }
+
+ @Test
+ public void missingRequiredProperty() {
+ // This test is compiled at source level 7 by CompileWithEclipseTest, so we can't use
+ // assertThrows with a lambda.
+ try {
+ localTimeBuilder().hour(12).minute(34).build();
+ fail();
+ } catch (IllegalStateException e) {
+ assertThat(e).hasMessageThat().isEqualTo("Missing required properties: second");
+ }
+ }
+
+ static void throwException() throws IOException {
+ throw new IOException("oops");
+ }
+
+ static ThrowExceptionBuilder throwExceptionBuilder() {
+ return new AutoBuilder_AutoBuilderTest_ThrowExceptionBuilder();
+ }
+
+ @AutoBuilder(callMethod = "throwException")
+ interface ThrowExceptionBuilder {
+ void build() throws IOException;
+ }
+
+ @Test
+ public void emptyBuilderThrowsException() {
+ try {
+ throwExceptionBuilder().build();
+ fail();
+ } catch (IOException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("oops");
+ }
+ }
+
+ static class ListContainer {
+ private final ImmutableList<String> list;
+
+ ListContainer(ImmutableList<String> list) {
+ this.list = checkNotNull(list);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return o instanceof ListContainer && list.equals(((ListContainer) o).list);
+ }
+
+ @Override
+ public int hashCode() {
+ return list.hashCode();
+ }
+
+ @Override
+ public String toString() {
+ return list.toString();
+ }
+
+ static Builder builder() {
+ return new AutoBuilder_AutoBuilderTest_ListContainer_Builder();
+ }
+
+ @AutoBuilder
+ interface Builder {
+ Builder setList(Iterable<String> list);
+
+ ImmutableList.Builder<String> listBuilder();
+
+ ListContainer build();
+ }
+ }
+
+ @Test
+ public void propertyBuilder() {
+ ListContainer expected = new ListContainer(ImmutableList.of("one", "two", "three"));
+ ListContainer actual1 =
+ ListContainer.builder().setList(ImmutableList.of("one", "two", "three")).build();
+ assertThat(actual1).isEqualTo(expected);
+
+ ListContainer.Builder builder2 = ListContainer.builder();
+ builder2.listBuilder().add("one", "two", "three");
+ assertThat(builder2.build()).isEqualTo(expected);
+
+ ListContainer.Builder builder3 = ListContainer.builder().setList(ImmutableList.of("one"));
+ builder3.listBuilder().add("two", "three");
+ assertThat(builder3.build()).isEqualTo(expected);
+
+ ListContainer.Builder builder4 = ListContainer.builder();
+ builder4.listBuilder();
+ try {
+ builder4.setList(ImmutableList.of("one", "two", "three"));
+ fail();
+ } catch (IllegalStateException e) {
+ assertThat(e).hasMessageThat().isEqualTo("Cannot set list after calling listBuilder()");
+ }
+ }
+
+ static <T> String concatList(ImmutableList<T> list) {
+ // We're avoiding streams for now so we compile this in Java 7 mode in CompileWithEclipseTest.
+ StringBuilder sb = new StringBuilder();
+ for (T element : list) {
+ sb.append(element);
+ }
+ return sb.toString();
+ }
+
+ @AutoBuilder(callMethod = "concatList")
+ interface ConcatListCaller<T> {
+ ImmutableList.Builder<T> listBuilder();
+
+ String call();
+ }
+
+ @Test
+ public void propertyBuilderWithoutSetter() {
+ ConcatListCaller<Integer> caller = new AutoBuilder_AutoBuilderTest_ConcatListCaller<>();
+ caller.listBuilder().add(1, 1, 2, 3, 5, 8);
+ String s = caller.call();
+ assertThat(s).isEqualTo("112358");
+ }
+
+ static <K, V extends Number> Map<K, V> singletonMap(K key, V value) {
+ return Collections.singletonMap(key, value);
+ }
+
+ static <K, V extends Number> SingletonMapBuilder<K, V> singletonMapBuilder() {
+ return new AutoBuilder_AutoBuilderTest_SingletonMapBuilder<>();
+ }
+
+ @AutoBuilder(callMethod = "singletonMap")
+ interface SingletonMapBuilder<K, V extends Number> {
+ SingletonMapBuilder<K, V> key(K key);
+
+ SingletonMapBuilder<K, V> value(V value);
+
+ Map<K, V> build();
+ }
+
+ @Test
+ public void genericStaticMethod() {
+ ImmutableMap<String, Integer> expected = ImmutableMap.of("17", 17);
+ SingletonMapBuilder<String, Integer> builder = singletonMapBuilder();
+ Map<String, Integer> actual = builder.key("17").value(17).build();
+ assertThat(actual).isEqualTo(expected);
+ }
+
+ static class SingletonSet<E> extends AbstractSet<E> {
+ private final E element;
+
+ SingletonSet(E element) {
+ this.element = element;
+ }
+
+ @Override
+ public int size() {
+ return 1;
+ }
+
+ @Override
+ public Iterator<E> iterator() {
+ return new Iterator<E>() {
+ private boolean first = true;
+
+ @Override
+ public boolean hasNext() {
+ return first;
+ }
+
+ @Override
+ public E next() {
+ if (!first) {
+ throw new NoSuchElementException();
+ }
+ first = false;
+ return element;
+ }
+ };
+ }
+ }
+
+ @AutoBuilder(ofClass = SingletonSet.class)
+ interface SingletonSetBuilder<E> {
+ SingletonSetBuilder<E> setElement(E element);
+
+ SingletonSet<E> build();
+ }
+
+ static <E> SingletonSetBuilder<E> singletonSetBuilder() {
+ return new AutoBuilder_AutoBuilderTest_SingletonSetBuilder<>();
+ }
+
+ @Test
+ public void genericClass() {
+ ImmutableSet<String> expected = ImmutableSet.of("foo");
+ SingletonSetBuilder<String> builder = singletonSetBuilder();
+ Set<String> actual = builder.setElement("foo").build();
+ assertThat(actual).isEqualTo(expected);
+ }
+
+ static class TypedSingletonSet<E> extends SingletonSet<E> {
+ private final Class<?> type;
+
+ <T extends E> TypedSingletonSet(T element, Class<T> type) {
+ super(element);
+ this.type = type;
+ }
+
+ @Override
+ public String toString() {
+ return type.getName() + super.toString();
+ }
+ }
+
+ @AutoBuilder(ofClass = TypedSingletonSet.class)
+ interface TypedSingletonSetBuilder<E, T extends E> {
+ TypedSingletonSetBuilder<E, T> setElement(T element);
+
+ TypedSingletonSetBuilder<E, T> setType(Class<T> type);
+
+ TypedSingletonSet<E> build();
+ }
+
+ static <E, T extends E> TypedSingletonSetBuilder<E, T> typedSingletonSetBuilder() {
+ return new AutoBuilder_AutoBuilderTest_TypedSingletonSetBuilder<>();
+ }
+
+ @Test
+ public void genericClassWithGenericConstructor() {
+ TypedSingletonSetBuilder<CharSequence, String> builder = typedSingletonSetBuilder();
+ TypedSingletonSet<CharSequence> set = builder.setElement("foo").setType(String.class).build();
+ assertThat(set.toString()).isEqualTo("java.lang.String[foo]");
+ }
+
+ static <T> ImmutableList<T> pair(T first, T second) {
+ return ImmutableList.of(first, second);
+ }
+
+ @AutoBuilder(callMethod = "pair")
+ interface PairBuilder<T> {
+ PairBuilder<T> setFirst(T x);
+
+ T getFirst();
+
+ PairBuilder<T> setSecond(T x);
+
+ Optional<T> getSecond();
+
+ ImmutableList<T> build();
+ }
+
+ static <T> PairBuilder<T> pairBuilder() {
+ return new AutoBuilder_AutoBuilderTest_PairBuilder<>();
+ }
+
+ @Test
+ public void genericGetters() {
+ PairBuilder<Number> builder = pairBuilder();
+ assertThat(builder.getSecond()).isEmpty();
+ builder.setSecond(2);
+ assertThat(builder.getSecond()).hasValue(2);
+ try {
+ builder.getFirst();
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ builder.setFirst(1.0);
+ assertThat(builder.getFirst()).isEqualTo(1.0);
+ assertThat(builder.build()).containsExactly(1.0, 2).inOrder();
+ }
+}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java
index 1b58728..ee33740 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoOneOfTest.java
@@ -499,10 +499,7 @@
ArrayValue string = ArrayValue.ofString("foo");
ArrayValue ints1 = ArrayValue.ofInts(new int[] {17, 23});
ArrayValue ints2 = ArrayValue.ofInts(new int[] {17, 23});
- new EqualsTester()
- .addEqualityGroup(string)
- .addEqualityGroup(ints1, ints2)
- .testEquals();
+ new EqualsTester().addEqualityGroup(string).addEqualityGroup(ints1, ints2).testEquals();
}
@Retention(RetentionPolicy.RUNTIME)
@@ -560,8 +557,11 @@
@AutoOneOf(MaybeEmpty.Kind.class)
public abstract static class MaybeEmpty implements Serializable {
+ private static final long serialVersionUID = 1L;
+
public enum Kind {
- EMPTY, STRING,
+ EMPTY,
+ STRING,
}
public abstract Kind getKind();
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
index 10812f8..3f4e9bf 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java
@@ -15,9 +15,11 @@
*/
package com.google.auto.value;
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static com.google.common.truth.Truth8.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
import static com.google.testing.compile.CompilationSubject.assertThat;
import static org.junit.Assert.assertThrows;
import static org.junit.Assume.assumeTrue;
@@ -53,6 +55,7 @@
import javax.lang.model.util.ElementFilter;
import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;
+import org.junit.AssumptionViolatedException;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -153,6 +156,19 @@
.isEqualTo("NullableProperties{nullableString=null, randomInt=23}");
}
+ @Test
+ public void testEqualsParameterIsAnnotated() throws NoSuchMethodException {
+ // Sadly we can't rely on JDK 8 to handle type annotations correctly.
+ // Some versions do, some don't. So skip the test unless we are on at least JDK 9.
+ double javaVersion = Double.parseDouble(JAVA_SPECIFICATION_VERSION.value());
+ assume().that(javaVersion).isAtLeast(9.0);
+ Method equals =
+ NullableProperties.create(null, 23).getClass().getMethod("equals", Object.class);
+ AnnotatedType[] parameterTypes = equals.getAnnotatedParameterTypes();
+ assertThat(parameterTypes).hasLength(1);
+ assertThat(parameterTypes[0].getAnnotation(Nullable.class)).isNotNull();
+ }
+
@AutoAnnotation
static Nullable nullable() {
return new AutoAnnotation_AutoValueJava8Test_nullable();
@@ -162,9 +178,7 @@
public void testNullablePropertyImplementationIsNullable() throws NoSuchMethodException {
Method method =
AutoValue_AutoValueJava8Test_NullableProperties.class.getDeclaredMethod("nullableString");
- assertThat(method.getAnnotatedReturnType().getAnnotations())
- .asList()
- .contains(nullable());
+ assertThat(method.getAnnotatedReturnType().getAnnotations()).asList().contains(nullable());
}
@Test
@@ -198,8 +212,9 @@
@Test
public void testExcludedNullablePropertyImplementation() throws NoSuchMethodException {
- Method method = AutoValue_AutoValueJava8Test_NullablePropertiesNotCopied.class
- .getDeclaredMethod("nullableString");
+ Method method =
+ AutoValue_AutoValueJava8Test_NullablePropertiesNotCopied.class.getDeclaredMethod(
+ "nullableString");
assertThat(method.getAnnotatedReturnType().getAnnotations())
.asList()
.doesNotContain(nullable());
@@ -536,6 +551,35 @@
}
}
+ @AutoValue
+ abstract static class NoNullableRef {
+ abstract String foo();
+
+ static NoNullableRef of(String foo) {
+ return new AutoValue_AutoValueJava8Test_NoNullableRef(foo);
+ }
+ }
+
+ // Tests that we generate equals(@Nullable x) using JSpecify @Nullable if that annotation is
+ // available and there is no other @Nullable type annotation mentioned in the @AutoValue class.
+ // If there *are* other @Nullable type annotations, other test methods here will check that they
+ // are used instead.
+ @Test
+ public void testDefaultToJSpecifyNullable() throws ReflectiveOperationException {
+ Class<? extends Annotation> jspecifyNullable;
+ try {
+ // We write this using .concat in order to hide it from rewriting rules.
+ jspecifyNullable =
+ Class.forName("org".concat(".jspecify.nullness.Nullable")).asSubclass(Annotation.class);
+ } catch (ClassNotFoundException e) {
+ throw new AssumptionViolatedException("No JSpecify @Nullable available", e);
+ }
+ Class<? extends NoNullableRef> autoValueImpl = NoNullableRef.of("foo").getClass();
+ Method equals = autoValueImpl.getDeclaredMethod("equals", Object.class);
+ assertThat(equals.getAnnotatedParameterTypes()[0].isAnnotationPresent(jspecifyNullable))
+ .isTrue();
+ }
+
@Test
public void testBuilderWithUnprefixedGetter() {
assumeTrue(javacHandlesTypeAnnotationsCorrectly);
@@ -571,7 +615,7 @@
public abstract static class BuilderWithPrefixedGetters<T extends Comparable<T>> {
public abstract ImmutableList<T> getList();
- public abstract T getT();
+ public abstract @Nullable T getT();
@SuppressWarnings("mutable")
public abstract int @Nullable [] getInts();
@@ -586,7 +630,7 @@
public abstract static class Builder<T extends Comparable<T>> {
public abstract Builder<T> setList(ImmutableList<T> list);
- public abstract Builder<T> setT(T t);
+ public abstract Builder<T> setT(@Nullable T t);
public abstract Builder<T> setInts(int[] ints);
@@ -761,6 +805,7 @@
@AutoValue.Builder
abstract static class Builder {
abstract Builder maybeJustMaybe(Optional<String> maybe);
+
abstract OptionalOptional build();
}
}
@@ -795,6 +840,7 @@
@AutoValue.Builder
abstract static class Builder {
abstract Builder setPredicate(Predicate<? super Integer> predicate);
+
abstract OptionalExtends build();
}
}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java
index 346bc53..3a7e7bc 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/AutoValueTest.java
@@ -34,6 +34,7 @@
import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.ImmutableTable;
+import com.google.common.collect.Ordering;
import com.google.common.testing.EqualsTester;
import com.google.common.testing.SerializableTester;
import java.io.ObjectStreamClass;
@@ -52,6 +53,7 @@
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
@@ -60,6 +62,7 @@
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.SortedMap;
+import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import javax.annotation.Nullable;
@@ -70,6 +73,7 @@
/** @author emcmanus@google.com (Éamonn McManus) */
@RunWith(JUnit4.class)
+@SuppressWarnings({"AutoValueImmutableFields", "AutoValueFinalMethods", "TypeNameShadowing"})
public class AutoValueTest {
private static boolean omitIdentifiers;
@@ -180,12 +184,15 @@
@AutoValue
abstract static class StrangeGetters {
abstract int get1st();
+
abstract int get_1st(); // by default we'll use _1st where identifiers are needed, so foil that.
@AutoValue.Builder
abstract static class Builder {
abstract Builder set1st(int x);
+
abstract Builder set_1st(int x);
+
abstract StrangeGetters build();
}
@@ -284,6 +291,8 @@
@AutoValue
public abstract static class Serialize implements Serializable {
+ private static final long serialVersionUID = 1L;
+
public abstract int integer();
public abstract String string();
@@ -845,6 +854,8 @@
@Test
public void testGenericClassWithHairyBounds() throws Exception {
class ComparableList<E> extends ArrayList<E> implements Comparable<ComparableList<E>> {
+ private static final long serialVersionUID = 1L;
+
@Override
public int compareTo(ComparableList<E> list) {
throw new UnsupportedOperationException();
@@ -1262,7 +1273,7 @@
}
@AutoValue
- public abstract static class ComplexInheritance extends AbstractBase implements A, B {
+ public abstract static class ComplexInheritance extends AbstractBase implements IntfA, IntfB {
public static ComplexInheritance create(String name) {
return new AutoValue_AutoValueTest_ComplexInheritance(name);
}
@@ -1277,9 +1288,9 @@
}
}
- interface A extends Base {}
+ interface IntfA extends Base {}
- interface B extends Base {}
+ interface IntfB extends Base {}
interface Base {
int answer();
@@ -1352,7 +1363,7 @@
}
@AutoValue
- public abstract static class InheritTwice implements A, B {
+ public abstract static class InheritTwice implements IntfA, IntfB {
public static InheritTwice create(int answer) {
return new AutoValue_AutoValueTest_InheritTwice(answer);
}
@@ -1664,6 +1675,13 @@
.build();
assertThat(suppliedDirectly.optionalString()).hasValue("foo");
assertThat(suppliedDirectly.optionalInteger()).hasValue(23);
+
+ try {
+ // The parameter is not marked @Nullable so this should fail.
+ OptionalPropertiesWithBuilder.builder().setOptionalString((String) null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
}
@AutoValue
@@ -1874,6 +1892,40 @@
assertEquals((Integer) 17, instance3.u());
}
+ public interface ToBuilder<BuilderT> {
+ BuilderT toBuilder();
+ }
+
+ @AutoValue
+ public abstract static class InheritedToBuilder<T, U>
+ implements ToBuilder<InheritedToBuilder.Builder<T, U>> {
+
+ public abstract T t();
+
+ public abstract U u();
+
+ public static <T, U> Builder<T, U> builder() {
+ return new AutoValue_AutoValueTest_InheritedToBuilder.Builder<T, U>();
+ }
+
+ @AutoValue.Builder
+ public abstract static class Builder<T, U> {
+ public abstract Builder<T, U> setT(T t);
+
+ public abstract Builder<T, U> setU(U u);
+
+ public abstract InheritedToBuilder<T, U> build();
+ }
+ }
+
+ @Test
+ public void testInheritedToBuilder() {
+ InheritedToBuilder<Integer, String> x =
+ InheritedToBuilder.<Integer, String>builder().setT(17).setU("wibble").build();
+ InheritedToBuilder<Integer, String> y = x.toBuilder().setT(23).build();
+ assertThat(y.u()).isEqualTo("wibble");
+ }
+
@AutoValue
public abstract static class BuilderWithSet<T extends Comparable<T>> {
public abstract List<T> list();
@@ -2115,6 +2167,37 @@
}
@AutoValue
+ public abstract static class BuilderWithPrefixedGettersAndUnprefixedSetters {
+ public abstract String getOAuth();
+
+ public abstract String getOBrien();
+
+ public static Builder builder() {
+ return new AutoValue_AutoValueTest_BuilderWithPrefixedGettersAndUnprefixedSetters.Builder();
+ }
+
+ @AutoValue.Builder
+ public abstract static class Builder {
+ public abstract Builder oAuth(String x);
+
+ public abstract Builder OBrien(String x);
+
+ public abstract BuilderWithPrefixedGettersAndUnprefixedSetters build();
+ }
+ }
+
+ @Test
+ public void testBuilderWithPrefixedGetterAndUnprefixedSetter() {
+ BuilderWithPrefixedGettersAndUnprefixedSetters x =
+ BuilderWithPrefixedGettersAndUnprefixedSetters.builder()
+ .oAuth("OAuth")
+ .OBrien("Flann")
+ .build();
+ assertThat(x.getOAuth()).isEqualTo("OAuth");
+ assertThat(x.getOBrien()).isEqualTo("Flann");
+ }
+
+ @AutoValue
public abstract static class BuilderWithPropertyBuilders<FooT extends Comparable<FooT>> {
public abstract ImmutableList<FooT> getFoos();
@@ -2223,6 +2306,7 @@
@AutoValue.Builder
abstract static class Builder {
abstract ImmutableList.Builder<String> listBuilder();
+
abstract PropertyBuilderInheritsType build();
}
}
@@ -2820,6 +2904,8 @@
}
public static class MyMap<K, V> extends HashMap<K, V> {
+ private static final long serialVersionUID = 1L;
+
public MyMap() {}
public MyMap(Map<K, V> map) {
@@ -2828,6 +2914,8 @@
}
public static class MyMapBuilder<K, V> extends LinkedHashMap<K, V> {
+ private static final long serialVersionUID = 1L;
+
public MyMapBuilder() {}
public MyMapBuilder(Map<K, V> map) {
@@ -2873,6 +2961,8 @@
}
public static class MyStringMap<V> extends MyMap<String, V> {
+ private static final long serialVersionUID = 1L;
+
public MyStringMap() {}
public MyStringMap(Map<String, V> map) {
@@ -2885,6 +2975,8 @@
}
public static class MyStringMapBuilder<V> extends MyMapBuilder<String, V> {
+ private static final long serialVersionUID = 1L;
+
public MyStringMapBuilder() {}
public MyStringMapBuilder(Map<String, V> map) {
@@ -3258,6 +3350,7 @@
@AutoValue.Builder
abstract static class Builder {
abstract Builder setMetrics(ImmutableSet<? extends Number> metrics);
+
abstract GenericExtends build();
}
}
@@ -3282,6 +3375,7 @@
@AutoValue.Builder
abstract static class Builder {
abstract Builder setList(List<String> list);
+
abstract Child build();
}
}
@@ -3325,14 +3419,18 @@
@SuppressWarnings("ClassCanBeStatic")
static class OuterWithTypeParam<T extends Number> {
class InnerWithTypeParam<U> {}
+
class InnerWithoutTypeParam {}
+
static class Nested {}
}
@AutoValue
abstract static class Nesty {
abstract OuterWithTypeParam<Double>.InnerWithTypeParam<String> innerWithTypeParam();
+
abstract OuterWithTypeParam<Double>.InnerWithoutTypeParam innerWithoutTypeParam();
+
abstract OuterWithTypeParam.Nested nested();
static Builder builder() {
@@ -3343,8 +3441,11 @@
abstract static class Builder {
abstract Builder setInnerWithTypeParam(
OuterWithTypeParam<Double>.InnerWithTypeParam<String> x);
+
abstract Builder setInnerWithoutTypeParam(OuterWithTypeParam<Double>.InnerWithoutTypeParam x);
+
abstract Builder setNested(OuterWithTypeParam.Nested x);
+
abstract Nesty build();
}
}
@@ -3353,11 +3454,12 @@
public void outerWithTypeParam() throws ReflectiveOperationException {
@SuppressWarnings("UseDiamond") // Currently we compile this with -source 6 in the Eclipse test.
OuterWithTypeParam<Double> outer = new OuterWithTypeParam<Double>();
- Nesty nesty = Nesty.builder()
- .setInnerWithTypeParam(outer.new InnerWithTypeParam<String>())
- .setInnerWithoutTypeParam(outer.new InnerWithoutTypeParam())
- .setNested(new OuterWithTypeParam.Nested())
- .build();
+ Nesty nesty =
+ Nesty.builder()
+ .setInnerWithTypeParam(outer.new InnerWithTypeParam<String>())
+ .setInnerWithoutTypeParam(outer.new InnerWithoutTypeParam())
+ .setNested(new OuterWithTypeParam.Nested())
+ .build();
Type originalReturnType =
Nesty.class.getDeclaredMethod("innerWithTypeParam").getGenericReturnType();
Type generatedReturnType =
@@ -3383,6 +3485,7 @@
@MyAnnotation("thing")
abstract static class Builder {
abstract Builder setFoo(String x);
+
abstract BuilderAnnotationsNotCopied build();
}
}
@@ -3407,6 +3510,7 @@
@MyAnnotation("thing")
abstract static class Builder {
abstract Builder setFoo(String x);
+
abstract BuilderAnnotationsCopied build();
}
}
@@ -3417,4 +3521,106 @@
assertThat(builder.getClass().getAnnotations()).asList().containsExactly(myAnnotation("thing"));
assertThat(builder.setFoo("foo").build().foo()).isEqualTo("foo");
}
+
+ @AutoValue
+ @AutoValue.CopyAnnotations
+ @SuppressWarnings({"rawtypes", "unchecked"}) // deliberately checking handling of raw types
+ abstract static class DataWithSortedCollectionBuilders<K, V> {
+ abstract ImmutableSortedMap<K, V> anImmutableSortedMap();
+
+ abstract ImmutableSortedSet<V> anImmutableSortedSet();
+
+ abstract ImmutableSortedMap<Integer, V> nonGenericImmutableSortedMap();
+
+ abstract ImmutableSortedSet rawImmutableSortedSet();
+
+ abstract DataWithSortedCollectionBuilders.Builder<K, V> toBuilder();
+
+ static <K, V> DataWithSortedCollectionBuilders.Builder<K, V> builder() {
+ return new AutoValue_AutoValueTest_DataWithSortedCollectionBuilders.Builder<K, V>();
+ }
+
+ @AutoValue.Builder
+ abstract static class Builder<K, V> {
+ abstract DataWithSortedCollectionBuilders.Builder<K, V> anImmutableSortedMap(
+ SortedMap<K, V> anImmutableSortedMap);
+
+ abstract ImmutableSortedMap.Builder<K, V> anImmutableSortedMapBuilder(
+ Comparator<K> keyComparator);
+
+ abstract DataWithSortedCollectionBuilders.Builder<K, V> anImmutableSortedSet(
+ SortedSet<V> anImmutableSortedSet);
+
+ abstract ImmutableSortedSet.Builder<V> anImmutableSortedSetBuilder(Comparator<V> comparator);
+
+ abstract ImmutableSortedMap.Builder<Integer, V> nonGenericImmutableSortedMapBuilder(
+ Comparator<Integer> keyComparator);
+
+ abstract ImmutableSortedSet.Builder rawImmutableSortedSetBuilder(Comparator comparator);
+
+ abstract DataWithSortedCollectionBuilders<K, V> build();
+ }
+ }
+
+ @Test
+ @SuppressWarnings({"rawtypes", "unchecked"}) // deliberately checking handling of raw types
+ public void shouldGenerateBuildersWithComparators() {
+ Comparator<String> stringComparator =
+ new Comparator<String>() {
+ @Override
+ public int compare(String left, String right) {
+ return left.compareTo(right);
+ }
+ };
+
+ Comparator<Integer> intComparator =
+ new Comparator<Integer>() {
+ @Override
+ public int compare(Integer o1, Integer o2) {
+ return o1 - o2;
+ }
+ };
+
+ Comparator comparator =
+ new Comparator() {
+ @Override
+ public int compare(Object left, Object right) {
+ return String.valueOf(left).compareTo(String.valueOf(right));
+ }
+ };
+
+ AutoValueTest.DataWithSortedCollectionBuilders.Builder<String, Integer> builder =
+ AutoValueTest.DataWithSortedCollectionBuilders.builder();
+
+ builder
+ .anImmutableSortedMapBuilder(stringComparator)
+ .put("Charlie", 1)
+ .put("Alfa", 2)
+ .put("Bravo", 3);
+ builder.anImmutableSortedSetBuilder(intComparator).add(1, 5, 9, 3);
+ builder.nonGenericImmutableSortedMapBuilder(intComparator).put(9, 99).put(1, 11).put(3, 33);
+ builder.rawImmutableSortedSetBuilder(comparator).add("Bravo", "Charlie", "Alfa");
+
+ AutoValueTest.DataWithSortedCollectionBuilders<String, Integer> data = builder.build();
+
+ AutoValueTest.DataWithSortedCollectionBuilders.Builder<String, Integer> copiedBuilder =
+ data.toBuilder();
+ AutoValueTest.DataWithSortedCollectionBuilders<String, Integer> copiedData =
+ copiedBuilder.build();
+
+ assertThat(data.anImmutableSortedMap().keySet())
+ .containsExactly("Alfa", "Bravo", "Charlie")
+ .inOrder();
+ assertThat(data.anImmutableSortedSet()).containsExactly(1, 3, 5, 9).inOrder();
+ assertThat(data.nonGenericImmutableSortedMap().keySet()).containsExactly(1, 3, 9).inOrder();
+ assertThat(data.rawImmutableSortedSet()).containsExactly("Alfa", "Bravo", "Charlie").inOrder();
+
+ assertThat(copiedData).isEqualTo(data);
+
+ try {
+ builder.anImmutableSortedMapBuilder(Ordering.from(stringComparator).reverse());
+ fail("Calling property builder method a second time should have failed");
+ } catch (IllegalStateException expected) {
+ }
+ }
}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/CompileWithEclipseTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/CompileWithEclipseTest.java
index 1518827..ca10fb4 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/CompileWithEclipseTest.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/CompileWithEclipseTest.java
@@ -21,6 +21,7 @@
import static com.google.common.truth.Truth.assertWithMessage;
import com.google.auto.value.processor.AutoAnnotationProcessor;
+import com.google.auto.value.processor.AutoBuilderProcessor;
import com.google.auto.value.processor.AutoOneOfProcessor;
import com.google.auto.value.processor.AutoValueProcessor;
import com.google.common.collect.ImmutableList;
@@ -58,25 +59,28 @@
@BeforeClass
public static void setSourceRoot() {
assertWithMessage("basedir property must be set - test must be run from Maven")
- .that(SOURCE_ROOT).isNotNull();
+ .that(SOURCE_ROOT)
+ .isNotNull();
}
public @Rule TemporaryFolder tmp = new TemporaryFolder();
private static final ImmutableSet<String> IGNORED_TEST_FILES =
- ImmutableSet.of("AutoValueNotEclipseTest.java", "CompileWithEclipseTest.java");
+ ImmutableSet.of(
+ "AutoValueNotEclipseTest.java", "CompileWithEclipseTest.java", "GradleTest.java");
private static final Predicate<File> JAVA_FILE =
f -> f.getName().endsWith(".java") && !IGNORED_TEST_FILES.contains(f.getName());
private static final Predicate<File> JAVA8_TEST =
- f -> f.getName().equals("AutoValueJava8Test.java")
- || f.getName().equals("AutoOneOfJava8Test.java")
- || f.getName().equals("EmptyExtension.java");
+ f ->
+ f.getName().equals("AutoValueJava8Test.java")
+ || f.getName().equals("AutoOneOfJava8Test.java")
+ || f.getName().equals("EmptyExtension.java");
@Test
- public void compileWithEclipseJava6() throws Exception {
- compileWithEclipse("6", JAVA_FILE.and(JAVA8_TEST.negate()));
+ public void compileWithEclipseJava7() throws Exception {
+ compileWithEclipse("7", JAVA_FILE.and(JAVA8_TEST.negate()));
}
@Test
@@ -103,17 +107,28 @@
// fileManager.getLocation(SYSTEM_MODULES).
File rtJar = new File(JAVA_HOME.value() + "/lib/rt.jar");
if (rtJar.exists()) {
- List<File> bootClassPath = ImmutableList.<File>builder()
- .add(rtJar)
- .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH))
- .build();
+ List<File> bootClassPath =
+ ImmutableList.<File>builder()
+ .add(rtJar)
+ .addAll(fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH))
+ .build();
fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
}
Iterable<? extends JavaFileObject> sourceFileObjects =
fileManager.getJavaFileObjectsFromFiles(sources);
String outputDir = tmp.getRoot().toString();
ImmutableList<String> options =
- ImmutableList.of("-d", outputDir, "-s", outputDir, "-source", version, "-target", version);
+ ImmutableList.of(
+ "-d",
+ outputDir,
+ "-s",
+ outputDir,
+ "-source",
+ version,
+ "-target",
+ version,
+ "-warn:-warningToken,-intfAnnotation",
+ "-Acom.google.auto.value.AutoBuilderIsUnstable");
JavaCompiler.CompilationTask task =
compiler.getTask(null, fileManager, null, options, null, sourceFileObjects);
// Explicitly supply an empty list of extensions for AutoValueProcessor, because otherwise this
@@ -121,7 +136,10 @@
AutoValueProcessor autoValueProcessor = new AutoValueProcessor(ImmutableList.of());
ImmutableList<? extends Processor> processors =
ImmutableList.of(
- autoValueProcessor, new AutoOneOfProcessor(), new AutoAnnotationProcessor());
+ autoValueProcessor,
+ new AutoOneOfProcessor(),
+ new AutoAnnotationProcessor(),
+ new AutoBuilderProcessor());
task.setProcessors(processors);
assertWithMessage("Compilation should succeed").that(task.call()).isTrue();
}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java b/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java
new file mode 100644
index 0000000..f4eb538
--- /dev/null
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/GradleTest.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.collect.ImmutableList;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+import org.gradle.testkit.runner.BuildResult;
+import org.gradle.testkit.runner.GradleRunner;
+import org.gradle.util.GradleVersion;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GradleTest {
+ @Rule public TemporaryFolder fakeProject = new TemporaryFolder();
+
+ private static final String BUILD_GRADLE_TEXT =
+ String.join(
+ "\n",
+ "plugins {",
+ " id 'java-library'",
+ "}",
+ "repositories {",
+ " maven { url = uri('${localRepository}') }",
+ "}",
+ "dependencies {",
+ " compileOnlyApi "
+ + " 'com.google.auto.value:auto-value-annotations:${autoValueVersion}'",
+ " annotationProcessor 'com.google.auto.value:auto-value:${autoValueVersion}'",
+ "}");
+
+ private static final String FOO_TEXT =
+ String.join(
+ "\n",
+ "package com.example;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "",
+ "@AutoValue",
+ "abstract class Foo {",
+ " abstract String bar();",
+ "",
+ " static Foo of(String bar) {",
+ " return new AutoValue_Foo(bar);",
+ " }",
+ "}");
+
+ private static final Optional<File> GRADLE_INSTALLATION = getGradleInstallation();
+
+ @Test
+ public void basic() throws IOException {
+ String autoValueVersion = System.getProperty("autoValueVersion");
+ assertThat(autoValueVersion).isNotNull();
+ String localRepository = System.getProperty("localRepository");
+ assertThat(localRepository).isNotNull();
+
+ // Set up the fake Gradle project.
+ String buildGradleText = expandSystemProperties(BUILD_GRADLE_TEXT);
+ writeFile(fakeProject.newFile("build.gradle").toPath(), buildGradleText);
+ Path srcDir = fakeProject.newFolder("src", "main", "java", "com", "example").toPath();
+ writeFile(srcDir.resolve("Foo.java"), FOO_TEXT);
+
+ // Build it the first time.
+ BuildResult result1 = buildFakeProject();
+ assertThat(result1.getOutput())
+ .contains(
+ "Full recompilation is required because no incremental change information is"
+ + " available");
+ Path output =
+ fakeProject
+ .getRoot()
+ .toPath()
+ .resolve("build/classes/java/main/com/example/AutoValue_Foo.class");
+ assertThat(Files.exists(output)).isTrue();
+
+ // Add a source file to the project.
+ String barText = FOO_TEXT.replace("Foo", "Bar");
+ Path barFile = srcDir.resolve("Bar.java");
+ writeFile(barFile, barText);
+
+ // Build it a second time.
+ BuildResult result2 = buildFakeProject();
+ assertThat(result2.getOutput()).doesNotContain("Full recompilation is required");
+
+ // Remove the second source file and build a third time. If incremental annotation processing
+ // is not working, this will produce a message like this:
+ // Full recompilation is required because com.google.auto.value.processor.AutoValueProcessor
+ // is not incremental
+ Files.delete(barFile);
+ BuildResult result3 = buildFakeProject();
+ assertThat(result3.getOutput()).doesNotContain("Full recompilation is required");
+ }
+
+ private BuildResult buildFakeProject() throws IOException {
+ GradleRunner runner =
+ GradleRunner.create()
+ .withProjectDir(fakeProject.getRoot())
+ .withArguments("--info", "compileJava");
+ if (GRADLE_INSTALLATION.isPresent()) {
+ runner.withGradleInstallation(GRADLE_INSTALLATION.get());
+ } else {
+ runner.withGradleVersion(GradleVersion.current().getVersion());
+ }
+ return runner.build();
+ }
+
+ private static Optional<File> getGradleInstallation() {
+ String gradleHome = System.getenv("GRADLE_HOME");
+ if (gradleHome != null) {
+ File gradleHomeFile = new File(gradleHome);
+ if (gradleHomeFile.isDirectory()) {
+ return Optional.of(new File(gradleHome));
+ }
+ }
+ try {
+ Path gradleExecutable = Paths.get("/usr/bin/gradle");
+ Path gradleLink = gradleExecutable.resolveSibling(Files.readSymbolicLink(gradleExecutable));
+ if (!gradleLink.endsWith("bin/gradle")) {
+ return Optional.empty();
+ }
+ Path installationPath = gradleLink.getParent().getParent();
+ if (!Files.isDirectory(installationPath)) {
+ return Optional.empty();
+ }
+ Optional<Path> coreJar;
+ Pattern corePattern = Pattern.compile("gradle-core-([0-9]+)\\..*\\.jar");
+ try (Stream<Path> files = Files.walk(installationPath.resolve("lib"))) {
+ coreJar =
+ files
+ .filter(
+ p -> {
+ Matcher matcher = corePattern.matcher(p.getFileName().toString());
+ if (matcher.matches()) {
+ int version = Integer.parseInt(matcher.group(1));
+ if (version >= 5) {
+ return true;
+ }
+ }
+ return false;
+ })
+ .findFirst();
+ }
+ return coreJar.map(unused -> installationPath.toFile());
+ } catch (IOException e) {
+ return Optional.empty();
+ }
+ }
+
+ private static String expandSystemProperties(String s) {
+ for (String name : System.getProperties().stringPropertyNames()) {
+ String value = System.getProperty(name);
+ s = s.replace("${" + name + "}", value);
+ }
+ return s;
+ }
+
+ private static void writeFile(Path file, String text) throws IOException {
+ Files.write(file, ImmutableList.of(text), UTF_8);
+ }
+}
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/KotlinData.kt b/value/src/it/functional/src/test/java/com/google/auto/value/KotlinData.kt
new file mode 100644
index 0000000..f331889
--- /dev/null
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/KotlinData.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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
+
+data class KotlinData(val int: Int, val string: String)
+
+data class KotlinDataWithNullable(val anInt: Int?, val aString: String?)
+
+data class KotlinDataWithDefaults(val anInt: Int = 23, val aString: String = "skidoo")
diff --git a/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java b/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java
index 0476906..e6f7abf 100644
--- a/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java
+++ b/value/src/it/functional/src/test/java/com/google/auto/value/gwt/EmptyExtension.java
@@ -99,8 +99,7 @@
if (typeParameters.isEmpty()) {
return "";
}
- return typeParameters
- .stream()
+ return typeParameters.stream()
.map(e -> e.getSimpleName().toString())
.collect(joining(", ", "<", ">"));
}
diff --git a/value/src/it/gwtserializer/pom.xml b/value/src/it/gwtserializer/pom.xml
index eea8952..42cc2fe 100644
--- a/value/src/it/gwtserializer/pom.xml
+++ b/value/src/it/gwtserializer/pom.xml
@@ -36,7 +36,7 @@
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt</artifactId>
- <version>2.8.2</version>
+ <version>2.9.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
@@ -94,17 +94,17 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.7.0</version>
+ <version>3.8.1</version>
<dependencies>
<dependency>
<groupId>org.codehaus.plexus</groupId>
<artifactId>plexus-java</artifactId>
- <version>0.9.4</version>
+ <version>1.0.7</version>
</dependency>
</dependencies>
<configuration>
- <source>1.7</source>
- <target>1.7</target>
+ <source>1.8</source>
+ <target>1.8</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
@@ -120,7 +120,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
- <version>3.0.2</version>
+ <version>3.2.0</version>
<executions>
<execution>
<!-- postpone resources:testResources until after compiler:testCompile to get generated sources -->
@@ -132,7 +132,7 @@
<plugin>
<groupId>net.ltgt.gwt.maven</groupId>
<artifactId>gwt-maven-plugin</artifactId>
- <version>1.0-rc-6</version>
+ <version>1.0.0</version>
<executions>
<execution>
<goals>
@@ -144,7 +144,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-deploy-plugin</artifactId>
- <version>2.7</version>
+ <version>2.8.2</version>
<configuration>
<!-- Build/test, but don't deploy -->
<skip>true</skip>
diff --git a/value/src/main/java/com/google/auto/value/AutoBuilder.java b/value/src/main/java/com/google/auto/value/AutoBuilder.java
new file mode 100644
index 0000000..b970900
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/AutoBuilder.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Specifies that the annotated interface or abstract class should be implemented as a builder.
+ * This is still unstable; uses outside Google may break.
+ *
+ * <p>A simple example:
+ *
+ * <pre>
+ *
+ * {@code @}AutoBuilder(ofClass = Person.class)
+ * abstract class PersonBuilder {
+ * static PersonBuilder builder() {
+ * return new AutoBuilder_PersonBuilder();
+ * }
+ *
+ * abstract PersonBuilder setName(String name);
+ * abstract PersonBuilder setId(int id);
+ * abstract Person build();
+ * }</pre>
+ *
+ * @see <a
+ * href="https://github.com/google/auto/blob/master/value/userguide/autobuilder.md">AutoBuilder
+ * User's Guide</a>
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.TYPE)
+public @interface AutoBuilder {
+ /**
+ * The static method from {@link #ofClass} to call when the build-method of the builder is called.
+ * By default this is empty, meaning that a constructor rather than a static method should be
+ * called. There can be more than one method with the given name, or more than one constructor, in
+ * which case the one to call is the one whose parameter names and types correspond to the
+ * abstract methods of the class or interface with the {@code @AutoBuilder} annotation.
+ */
+ String callMethod() default "";
+
+ /**
+ * The class or interface containing the constructor or static method that the generated builder
+ * will eventually call. By default this is the class or interface that <i>contains</i> the class
+ * or interface with the {@code @AutoBuilder} annotation.
+ */
+ Class<?> ofClass() default Void.class;
+}
diff --git a/value/src/main/java/com/google/auto/value/AutoValue.java b/value/src/main/java/com/google/auto/value/AutoValue.java
index 45a677c..d7541f6 100644
--- a/value/src/main/java/com/google/auto/value/AutoValue.java
+++ b/value/src/main/java/com/google/auto/value/AutoValue.java
@@ -98,7 +98,7 @@
* <p>If you want to copy annotations from your {@literal @}AutoValue-annotated class's methods to
* the generated fields in the AutoValue_... implementation, annotate your method
* with {@literal @}AutoValue.CopyAnnotations. For example, if Example.java is:<pre>
-
+ *
* {@code @}Immutable
* {@code @}AutoValue
* abstract class Example {
diff --git a/value/src/main/java/com/google/auto/value/extension/AutoValueExtension.java b/value/src/main/java/com/google/auto/value/extension/AutoValueExtension.java
index 2c8a3fb..343645a 100644
--- a/value/src/main/java/com/google/auto/value/extension/AutoValueExtension.java
+++ b/value/src/main/java/com/google/auto/value/extension/AutoValueExtension.java
@@ -121,12 +121,10 @@
* example, if you have...
*
* <pre>
- * interface Parent<T> {
+ * {@code interface Parent<T>} {
* T bar();
* }
- *
- * {@code @AutoValue abstract class Foo implements Parent<String> {...}}
- * </pre>
+ * {@code @AutoValue abstract class Foo implements Parent<String> {...}}</pre>
*
* ...then the type of the {@code bar} property in {@code Foo} is actually {@code String}, but
* the {@code ExecutableElement} will be the the method in {@code Parent}, whose return type is
@@ -418,11 +416,11 @@
* Context#abstractMethods()}.
*
* <p>For example, Android's {@code Parcelable} interface includes a <a
- * href="http://developer.android.com/reference/android/os/Parcelable.html#writeToParcel(android.os.Parcel,
- * int)">method</a> {@code void writeToParcel(Parcel, int)}. Normally AutoValue would not know
- * what to do with that abstract method. But an {@code AutoValueExtension} that understands {@code
- * Parcelable} can provide a useful implementation and return the {@code writeToParcel} method
- * here. That will prevent a warning about the method from AutoValue.
+ * href="http://developer.android.com/reference/android/os/Parcelable.html#writeToParcel(android.os.Parcel,int)">method</a>
+ * {@code void writeToParcel(Parcel, int)}. Normally AutoValue would not know what to do with that
+ * abstract method. But an {@code AutoValueExtension} that understands {@code Parcelable} can
+ * provide a useful implementation and return the {@code writeToParcel} method here. That will
+ * prevent a warning about the method from AutoValue.
*
* @param context the Context of the code generation for this class.
*/
diff --git a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java
index 0ca46bd..acbe1c0 100644
--- a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java
+++ b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizeExtension.java
@@ -19,18 +19,19 @@
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.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
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.joining;
import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
import static javax.lang.model.element.Modifier.ABSTRACT;
@@ -50,7 +51,6 @@
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.google.errorprone.annotations.FormatMethod;
@@ -65,9 +65,7 @@
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;
@@ -80,7 +78,6 @@
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;
@@ -126,13 +123,9 @@
}
private static ImmutableSet<ExecutableElement> memoizedMethods(Context context) {
- ImmutableSet.Builder<ExecutableElement> memoizedMethods = ImmutableSet.builder();
- for (ExecutableElement method : methodsIn(context.autoValueClass().getEnclosedElements())) {
- if (getAnnotationMirror(method, MEMOIZED_NAME).isPresent()) {
- memoizedMethods.add(method);
- }
- }
- return memoizedMethods.build();
+ return methodsIn(context.autoValueClass().getEnclosedElements()).stream()
+ .filter(m -> getAnnotationMirror(m, MEMOIZED_NAME).isPresent())
+ .collect(toImmutableSet());
}
static final class Generator {
@@ -164,7 +157,7 @@
classBuilder(className)
.superclass(superType())
.addAnnotations(copiedClassAnnotations(context.autoValueClass()))
- .addTypeVariables(typeVariableNames())
+ .addTypeVariables(annotatedTypeVariableNames())
.addModifiers(isFinal ? FINAL : ABSTRACT)
.addMethod(constructor());
generatedAnnotationSpec(elements, sourceVersion, MemoizeExtension.class)
@@ -183,6 +176,7 @@
return JavaFile.builder(context.packageName(), generated.build()).build().toString();
}
+ // LINT.IfChange
private TypeName superType() {
ClassName superType = ClassName.get(context.packageName(), classToExtend);
ImmutableList<TypeVariableName> typeVariableNames = typeVariableNames();
@@ -193,23 +187,31 @@
}
private ImmutableList<TypeVariableName> typeVariableNames() {
- ImmutableList.Builder<TypeVariableName> typeVariableNamesBuilder = ImmutableList.builder();
- for (TypeParameterElement typeParameter : context.autoValueClass().getTypeParameters()) {
- typeVariableNamesBuilder.add(TypeVariableName.get(typeParameter));
- }
- return typeVariableNamesBuilder.build();
+ return context.autoValueClass().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .collect(toImmutableList());
+ }
+
+ private ImmutableList<TypeVariableName> annotatedTypeVariableNames() {
+ return context.autoValueClass().getTypeParameters().stream()
+ .map(
+ p ->
+ TypeVariableName.get(p)
+ .annotated(
+ p.getAnnotationMirrors().stream()
+ .map(AnnotationSpec::get)
+ .collect(toImmutableList())))
+ .collect(toImmutableList());
}
private MethodSpec constructor() {
MethodSpec.Builder constructor = constructorBuilder();
- for (Map.Entry<String, TypeMirror> property : context.propertyTypes().entrySet()) {
- constructor.addParameter(annotatedType(property.getValue()), property.getKey() + "$");
- }
- List<String> namesWithDollars = new ArrayList<String>();
- for (String property : context.properties().keySet()) {
- namesWithDollars.add(property + "$");
- }
- constructor.addStatement("super($L)", Joiner.on(", ").join(namesWithDollars));
+ context
+ .propertyTypes()
+ .forEach((name, type) -> constructor.addParameter(annotatedType(type), name + "$"));
+ String superParams =
+ context.properties().keySet().stream().map(n -> n + "$").collect(joining(", "));
+ constructor.addStatement("super($L)", superParams);
return constructor.build();
}
@@ -250,6 +252,7 @@
.build();
}
+ // LINT.IfChange
/**
* 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
@@ -478,15 +481,15 @@
return elements.overrides(method, objectMethod(methodName), context.autoValueClass());
}
- private ExecutableElement objectMethod(final String methodName) {
+ private ExecutableElement objectMethod(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));
+ return methodsIn(object.getEnclosedElements()).stream()
+ .filter(m -> m.getSimpleName().contentEquals(methodName))
+ .findFirst()
+ .orElseThrow(
+ () ->
+ new IllegalArgumentException(
+ String.format("No method in Object named \"%s\"", methodName)));
}
private boolean pullDownMethodAnnotation(AnnotationMirror annotation) {
@@ -594,9 +597,7 @@
/** Translate a {@link TypeMirror} into a {@link TypeName}, including type annotations. */
private static TypeName annotatedType(TypeMirror type) {
List<AnnotationSpec> annotations =
- type.getAnnotationMirrors().stream()
- .map(AnnotationSpec::get)
- .collect(toList());
+ type.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(toList());
return TypeName.get(type).annotated(annotations);
}
}
diff --git a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java
index 5a77050..d250fbc 100644
--- a/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java
+++ b/value/src/main/java/com/google/auto/value/extension/memoized/processor/MemoizedValidator.java
@@ -37,8 +37,8 @@
import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType;
/**
- * An annotation {@link Processor} that reports errors for {@link Memoized @Memoized} methods that
- * are not inside {@code AutoValue}-annotated classes.
+ * An annotation {@link Processor} that reports errors for {@code @Memoized} methods that are not
+ * inside {@code AutoValue}-annotated classes.
*/
@AutoService(Processor.class)
@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.ISOLATING)
@@ -66,9 +66,7 @@
}
private static boolean isAutoValue(Element element) {
- return element
- .getAnnotationMirrors()
- .stream()
+ return element.getAnnotationMirrors().stream()
.map(annotation -> MoreTypes.asTypeElement(annotation.getAnnotationType()))
.anyMatch(type -> type.getQualifiedName().contentEquals("com.google.auto.value.AutoValue"));
}
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/userguide/index.md b/value/src/main/java/com/google/auto/value/extension/serializable/g3doc/index.md
similarity index 99%
rename from value/src/main/java/com/google/auto/value/extension/serializable/userguide/index.md
rename to value/src/main/java/com/google/auto/value/extension/serializable/g3doc/index.md
index e766183..0282404 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/userguide/index.md
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/g3doc/index.md
@@ -4,7 +4,6 @@
An [`AutoValue`] extension that enables `@AutoValue` classes with
un-serializable properties to be serializable.
-
## Usage
To use the [`SerializableAutoValueExtension`] with your `AutoValue` class, the
@@ -100,4 +99,3 @@
[`SerializableAutoValue`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/serializable/SerializableAutoValue.java
[`SerializableAutoValueExtension`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/serializable/extension/SerializableAutoValueExtension.java
[SerializerExtensions]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/serializable/userguide/serializer-extension.md
-
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/userguide/serializer-extension.md b/value/src/main/java/com/google/auto/value/extension/serializable/g3doc/serializer-extension.md
similarity index 99%
rename from value/src/main/java/com/google/auto/value/extension/serializable/userguide/serializer-extension.md
rename to value/src/main/java/com/google/auto/value/extension/serializable/g3doc/serializer-extension.md
index edfa3ca..aaec7c0 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/userguide/serializer-extension.md
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/g3doc/serializer-extension.md
@@ -243,4 +243,3 @@
[`SerializableAutoValueExtension`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/serializable/extension/SerializableAutoValueExtension.java
[`SerializerExtension`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/serializable/serializer/interfaces/SerializerExtension.java
[`Serializer`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/serializable/serializer/interfaces/Serializer.java
-
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtension.java b/value/src/main/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtension.java
index d3265d0..5143d8b 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtension.java
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtension.java
@@ -15,9 +15,9 @@
*/
package com.google.auto.value.extension.serializable.processor;
+import static com.google.auto.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreStreams.toImmutableMap;
import static com.google.auto.value.extension.serializable.processor.ClassNames.SERIALIZABLE_AUTO_VALUE_NAME;
-import static com.google.common.collect.ImmutableList.toImmutableList;
-import static com.google.common.collect.ImmutableMap.toImmutableMap;
import static java.util.stream.Collectors.joining;
import com.google.auto.common.GeneratedAnnotationSpecs;
@@ -59,6 +59,7 @@
* <li>The AutoValue class must implement {@link Serializable}.
* <li>Unserializable fields in the AutoValue class must be supported by a {@link
* com.google.auto.value.extension.serializable.serializer.interfaces.SerializerExtension}.
+ * </ul>
*/
@AutoService(AutoValueExtension.class)
public final class SerializableAutoValueExtension extends AutoValueExtension {
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/SerializerFactoryLoader.java b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/SerializerFactoryLoader.java
index 12984b0..e81b586 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/SerializerFactoryLoader.java
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/SerializerFactoryLoader.java
@@ -21,6 +21,8 @@
import com.google.auto.value.processor.SimpleServiceLoader;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableList;
+import java.util.Optional;
+import java.util.regex.Pattern;
import javax.annotation.processing.ProcessingEnvironment;
import javax.tools.Diagnostic;
@@ -40,10 +42,18 @@
private static ImmutableList<SerializerExtension> loadExtensions(
ProcessingEnvironment processingEnv) {
+ // The below is a workaround for a test-building bug. We don't expect to support it indefinitely
+ // so don't depend on it.
+ String allowedMissingClasses =
+ processingEnv.getOptions().get("allowedMissingSerializableExtensionClasses");
+ Optional<Pattern> allowedMissingClassesPattern =
+ Optional.ofNullable(allowedMissingClasses).map(Pattern::compile);
try {
return ImmutableList.copyOf(
SimpleServiceLoader.load(
- SerializerExtension.class, SerializerFactoryLoader.class.getClassLoader()));
+ SerializerExtension.class,
+ SerializerFactoryLoader.class.getClassLoader(),
+ allowedMissingClassesPattern));
} catch (Throwable t) {
processingEnv
.getMessager()
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableListSerializerExtension.java b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableListSerializerExtension.java
index 7ff4f19..a390add 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableListSerializerExtension.java
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableListSerializerExtension.java
@@ -55,17 +55,22 @@
return Optional.empty();
}
- return Optional.of(new ImmutableListSerializer(containedTypeSerializer, processingEnv));
+ return Optional.of(
+ new ImmutableListSerializer(containedTypeSerializer, factory, processingEnv));
}
private static class ImmutableListSerializer implements Serializer {
private final Serializer containedTypeSerializer;
+ private final SerializerFactory factory;
private final ProcessingEnvironment processingEnv;
ImmutableListSerializer(
- Serializer containedTypeSerializer, ProcessingEnvironment processingEnv) {
+ Serializer containedTypeSerializer,
+ SerializerFactory factory,
+ ProcessingEnvironment processingEnv) {
this.containedTypeSerializer = containedTypeSerializer;
+ this.factory = factory;
this.processingEnv = processingEnv;
}
@@ -81,7 +86,7 @@
@Override
public CodeBlock toProxy(CodeBlock expression) {
- CodeBlock element = CodeBlock.of("value$$");
+ CodeBlock element = factory.newIdentifier("value");
return CodeBlock.of(
"$L.stream().map($T.wrapper($L -> $L)).collect($T.toImmutableList())",
expression,
@@ -93,7 +98,7 @@
@Override
public CodeBlock fromProxy(CodeBlock expression) {
- CodeBlock element = CodeBlock.of("value$$");
+ CodeBlock element = factory.newIdentifier("value");
return CodeBlock.of(
"$L.stream().map($T.wrapper($L -> $L)).collect($T.toImmutableList())",
expression,
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableMapSerializerExtension.java b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableMapSerializerExtension.java
index 9d571e3..8d67e10 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableMapSerializerExtension.java
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/ImmutableMapSerializerExtension.java
@@ -60,7 +60,7 @@
return Optional.of(
new ImmutableMapSerializer(
- keyType, valueType, keyTypeSerializer, valueTypeSerializer, processingEnv));
+ keyType, valueType, keyTypeSerializer, valueTypeSerializer, factory, processingEnv));
}
private static class ImmutableMapSerializer implements Serializer {
@@ -71,6 +71,7 @@
private final TypeMirror valueProxyType;
private final Serializer keyTypeSerializer;
private final Serializer valueTypeSerializer;
+ private final SerializerFactory factory;
private final ProcessingEnvironment processingEnv;
ImmutableMapSerializer(
@@ -78,6 +79,7 @@
TypeMirror valueType,
Serializer keyTypeSerializer,
Serializer valueTypeSerializer,
+ SerializerFactory factory,
ProcessingEnvironment processingEnv) {
this.keyType = keyType;
this.valueType = valueType;
@@ -85,6 +87,7 @@
this.valueProxyType = valueTypeSerializer.proxyFieldType();
this.keyTypeSerializer = keyTypeSerializer;
this.valueTypeSerializer = valueTypeSerializer;
+ this.factory = factory;
this.processingEnv = processingEnv;
}
@@ -117,13 +120,15 @@
generateValueMapFunction(valueProxyType, valueType, valueTypeSerializer::fromProxy));
}
- private static CodeBlock generateKeyMapFunction(
+ private CodeBlock generateKeyMapFunction(
TypeMirror originalType,
TypeMirror transformedType,
Function<CodeBlock, CodeBlock> proxyMap) {
- CodeBlock element = CodeBlock.of("element$$");
+ CodeBlock element = factory.newIdentifier("element");
+ CodeBlock value = factory.newIdentifier("value");
return CodeBlock.of(
- "value$$ -> $T.<$T, $T>wrapper($L -> $L).apply(value$$.getKey())",
+ "$1L -> $2T.<$3T, $4T>wrapper($5L -> $6L).apply($1L.getKey())",
+ value,
FunctionWithExceptions.class,
originalType,
transformedType,
@@ -131,13 +136,15 @@
proxyMap.apply(element));
}
- private static CodeBlock generateValueMapFunction(
+ private CodeBlock generateValueMapFunction(
TypeMirror originalType,
TypeMirror transformedType,
Function<CodeBlock, CodeBlock> proxyMap) {
- CodeBlock element = CodeBlock.of("element$$");
+ CodeBlock element = factory.newIdentifier("element");
+ CodeBlock value = factory.newIdentifier("value");
return CodeBlock.of(
- "value$$ -> $T.<$T, $T>wrapper($L -> $L).apply(value$$.getValue())",
+ "$1L -> $2T.<$3T, $4T>wrapper($5L -> $6L).apply($1L.getValue())",
+ value,
FunctionWithExceptions.class,
originalType,
transformedType,
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/SerializerFactoryImpl.java b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/SerializerFactoryImpl.java
index 57741f9..7c55289 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/SerializerFactoryImpl.java
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/impl/SerializerFactoryImpl.java
@@ -19,7 +19,9 @@
import com.google.auto.value.extension.serializable.serializer.interfaces.SerializerExtension;
import com.google.auto.value.extension.serializable.serializer.interfaces.SerializerFactory;
import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.CodeBlock;
import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.type.TypeMirror;
@@ -28,6 +30,7 @@
private final ImmutableList<SerializerExtension> extensions;
private final ProcessingEnvironment env;
+ private final AtomicInteger idCount = new AtomicInteger();
public SerializerFactoryImpl(
ImmutableList<SerializerExtension> extensions, ProcessingEnvironment env) {
@@ -45,4 +48,9 @@
}
return IdentitySerializerFactory.getSerializer(typeMirror);
}
+
+ @Override
+ public CodeBlock newIdentifier(String prefix) {
+ return CodeBlock.of("$L$$$L", prefix, idCount.incrementAndGet());
+ }
}
diff --git a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/interfaces/SerializerFactory.java b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/interfaces/SerializerFactory.java
index d05c88b..2b54225 100644
--- a/value/src/main/java/com/google/auto/value/extension/serializable/serializer/interfaces/SerializerFactory.java
+++ b/value/src/main/java/com/google/auto/value/extension/serializable/serializer/interfaces/SerializerFactory.java
@@ -15,6 +15,7 @@
*/
package com.google.auto.value.extension.serializable.serializer.interfaces;
+import com.squareup.javapoet.CodeBlock;
import javax.lang.model.type.TypeMirror;
/**
@@ -26,4 +27,16 @@
/** Returns a {@link Serializer} for the given {@link TypeMirror}. */
Serializer getSerializer(TypeMirror type);
+
+ /**
+ * Returns an identifier beginning with the given prefix and that is distinct from any identifier
+ * returned by another call to this method. The returned identifier will contain a {@code $},
+ * which should also mean it is distinct from identifiers in user code that are in scope.
+ *
+ * <p>The default implementation of this method throws {@link UnsupportedOperationException} for
+ * compatibility reasons.
+ */
+ default CodeBlock newIdentifier(String prefix) {
+ throw new UnsupportedOperationException();
+ }
}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/ToPrettyString.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/ToPrettyString.java
new file mode 100644
index 0000000..cd2762a
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/ToPrettyString.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring;
+
+import static java.lang.annotation.ElementType.METHOD;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Target;
+import java.util.Collection;
+
+/**
+ * Annotates instance methods that return an easy-to-read {@link String} representing the instance.
+ * When the method is {@code abstract} and enclosed in an {@link com.google.auto.value.AutoValue}
+ * class, an implementation of the method will be automatically generated.
+ *
+ * <p>When generating an implementation of an {@code @ToPrettyString} method, each property of the
+ * {@code @AutoValue} type is individually printed in an easy-to-read format. If the type of the
+ * property itself has a {@code @ToPrettyString} method, that method will be called in assistance of
+ * computing the pretty string. Non-{@code @AutoValue} classes can contribute a pretty string
+ * representation by annotating a method with {@code @ToPrettyString}.
+ *
+ * <p>{@link Collection} and {@link Collection}-like types have special representations in generated
+ * pretty strings.
+ *
+ * <p>If no {@code @ToPrettyString} method is found on a type and the type is not one with a built
+ * in rendering, the {@link Object#toString()} value will be used instead.
+ *
+ * <p>{@code @ToPrettyString} is valid on overridden {@code toString()} and other methods alike.
+ *
+ * <h3>Example</h3>
+ *
+ * <pre>
+ * {@code @AutoValue}
+ * abstract class Pretty {
+ * abstract {@code List<String>} property();
+ *
+ * {@code @ToPrettyString}
+ * abstract String toPrettyString();
+ * }
+ *
+ * System.out.println(new AutoValue_Pretty(List.of("abc", "def", "has\nnewline)).toPrettyString())
+ * // Pretty{
+ * // property = [
+ * // abc,
+ * // def,
+ * // has
+ * // newline,
+ * // ]
+ * // }
+ * }</pre>
+ */
+@Documented
+@Target(METHOD)
+public @interface ToPrettyString {}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/Annotations.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/Annotations.java
new file mode 100644
index 0000000..255d6c9
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/Annotations.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring.processor;
+
+import static com.google.auto.value.extension.toprettystring.processor.ClassNames.TO_PRETTY_STRING_NAME;
+
+import com.google.auto.common.MoreTypes;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** Extension methods for working with {@link AnnotationMirror}. */
+final class Annotations {
+ static Optional<AnnotationMirror> getAnnotationMirror(Element element, String annotationName) {
+ for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
+ TypeElement annotationElement = MoreTypes.asTypeElement(annotation.getAnnotationType());
+ if (annotationElement.getQualifiedName().contentEquals(annotationName)) {
+ return Optional.of(annotation);
+ }
+ }
+ return Optional.empty();
+ }
+
+ static Optional<AnnotationMirror> toPrettyStringAnnotation(Element element) {
+ return getAnnotationMirror(element, TO_PRETTY_STRING_NAME);
+ }
+
+ private Annotations() {}
+}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ClassNames.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ClassNames.java
new file mode 100644
index 0000000..0cfd577
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ClassNames.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring.processor;
+
+/** Names of classes that are referenced in the processor/extension. */
+final class ClassNames {
+ static final String TO_PRETTY_STRING_NAME =
+ "com.google.auto.value.extension.toprettystring.ToPrettyString";
+
+ private ClassNames() {}
+}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ExtensionClassTypeSpecBuilder.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ExtensionClassTypeSpecBuilder.java
new file mode 100644
index 0000000..e2381f7
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ExtensionClassTypeSpecBuilder.java
@@ -0,0 +1,297 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring.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.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
+import static com.google.auto.value.extension.toprettystring.processor.Annotations.getAnnotationMirror;
+import static com.google.common.collect.Sets.union;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static java.util.stream.Collectors.joining;
+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 com.google.auto.common.MoreTypes;
+import com.google.auto.common.Visibility;
+import com.google.auto.value.extension.AutoValueExtension;
+import com.google.auto.value.extension.AutoValueExtension.Context;
+import com.google.common.base.Equivalence.Wrapper;
+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.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.List;
+import java.util.Optional;
+import java.util.Set;
+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.QualifiedNameable;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+/**
+ * A factory for {@link TypeSpec}s used in {@link AutoValueExtension} implementations.
+ *
+ * <p>This is copied from {@link
+ * com.google.auto.value.extension.memoized.processor.MemoizeExtension} until we find a better
+ * location to consolidate the code.
+ */
+final class ExtensionClassTypeSpecBuilder {
+ 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 final Context context;
+ private final String className;
+ private final String classToExtend;
+ private final boolean isFinal;
+ private final Types types;
+ private final Elements elements;
+ private final SourceVersion sourceVersion;
+
+ private ExtensionClassTypeSpecBuilder(
+ Context context, String className, String classToExtend, boolean isFinal) {
+ this.context = context;
+ this.className = className;
+ this.classToExtend = classToExtend;
+ this.isFinal = isFinal;
+ this.types = context.processingEnvironment().getTypeUtils();
+ this.elements = context.processingEnvironment().getElementUtils();
+ this.sourceVersion = context.processingEnvironment().getSourceVersion();
+ }
+
+ static TypeSpec.Builder extensionClassTypeSpecBuilder(
+ Context context, String className, String classToExtend, boolean isFinal) {
+ return new ExtensionClassTypeSpecBuilder(context, className, classToExtend, isFinal)
+ .extensionClassBuilder();
+ }
+
+ TypeSpec.Builder extensionClassBuilder() {
+ TypeSpec.Builder builder =
+ classBuilder(className)
+ .superclass(superType())
+ .addAnnotations(copiedClassAnnotations(context.autoValueClass()))
+ .addTypeVariables(annotatedTypeVariableNames())
+ .addModifiers(isFinal ? FINAL : ABSTRACT)
+ .addMethod(constructor());
+ generatedAnnotationSpec(elements, sourceVersion, ToPrettyStringExtension.class)
+ .ifPresent(builder::addAnnotation);
+ return builder;
+ }
+
+ private TypeName superType() {
+ ClassName superType = ClassName.get(context.packageName(), classToExtend);
+ ImmutableList<TypeVariableName> typeVariableNames = typeVariableNames();
+
+ return typeVariableNames.isEmpty()
+ ? superType
+ : ParameterizedTypeName.get(superType, typeVariableNames.toArray(new TypeName[] {}));
+ }
+
+ private ImmutableList<TypeVariableName> typeVariableNames() {
+ return context.autoValueClass().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .collect(toImmutableList());
+ }
+
+ private ImmutableList<TypeVariableName> annotatedTypeVariableNames() {
+ return context.autoValueClass().getTypeParameters().stream()
+ .map(
+ p ->
+ TypeVariableName.get(p)
+ .annotated(
+ p.getAnnotationMirrors().stream()
+ .map(AnnotationSpec::get)
+ .collect(toImmutableList())))
+ .collect(toImmutableList());
+ }
+
+ private MethodSpec constructor() {
+ MethodSpec.Builder constructor = constructorBuilder();
+ context
+ .propertyTypes()
+ .forEach((name, type) -> constructor.addParameter(annotatedType(type), name + "$"));
+ String superParams =
+ context.properties().keySet().stream().map(n -> n + "$").collect(joining(", "));
+ constructor.addStatement("super($L)", superParams);
+ return constructor.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<AnnotationMirror> annotationsToCopy(
+ Element autoValueType, Element typeOrMethod, Set<String> excludedAnnotations) {
+ ImmutableList.Builder<AnnotationMirror> 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<AnnotationSpec> copyAnnotations(
+ Element autoValueType, Element typeOrMethod, Set<String> excludedAnnotations) {
+ ImmutableList<AnnotationMirror> 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<TypeMirror> getExcludedAnnotationTypes(Element element) {
+ Optional<AnnotationMirror> maybeAnnotation =
+ getAnnotationMirror(element, COPY_ANNOTATIONS_NAME);
+ if (!maybeAnnotation.isPresent()) {
+ return ImmutableSet.of();
+ }
+
+ @SuppressWarnings("unchecked")
+ List<AnnotationValue> excludedClasses =
+ (List<AnnotationValue>) 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<String> 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<String> getAnnotationsMarkedWithInherited(Element element) {
+ return element.getAnnotationMirrors().stream()
+ .filter(a -> isAnnotationPresent(a.getAnnotationType().asElement(), Inherited.class))
+ .map(ExtensionClassTypeSpecBuilder::getAnnotationFqName)
+ .collect(toSet());
+ }
+
+ private ImmutableList<AnnotationSpec> copiedClassAnnotations(TypeElement type) {
+ // Only copy annotations from a class if it has @AutoValue.CopyAnnotations.
+ if (hasAnnotationMirror(type, COPY_ANNOTATIONS_NAME)) {
+ Set<String> excludedAnnotations =
+ union(getExcludedAnnotationClassNames(type), getAnnotationsMarkedWithInherited(type));
+
+ return copyAnnotations(type, type, excludedAnnotations);
+ } else {
+ return ImmutableList.of();
+ }
+ }
+
+ /** Translate a {@link TypeMirror} into a {@link TypeName}, including type annotations. */
+ private static TypeName annotatedType(TypeMirror type) {
+ List<AnnotationSpec> annotations =
+ type.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(toList());
+
+ return TypeName.get(type).annotated(annotations);
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringExtension.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringExtension.java
new file mode 100644
index 0000000..134fcac
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringExtension.java
@@ -0,0 +1,562 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring.processor;
+
+import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.auto.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.auto.value.extension.toprettystring.processor.ExtensionClassTypeSpecBuilder.extensionClassTypeSpecBuilder;
+import static com.google.auto.value.extension.toprettystring.processor.ToPrettyStringMethods.toPrettyStringMethod;
+import static com.google.auto.value.extension.toprettystring.processor.ToPrettyStringMethods.toPrettyStringMethods;
+import static com.google.common.collect.Iterables.getLast;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.collect.Sets.intersection;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PROTECTED;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.service.AutoService;
+import com.google.auto.value.extension.AutoValueExtension;
+import com.google.auto.value.extension.toprettystring.processor.ToPrettyStringExtension.PrettyPrintableKind.KindVisitor;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Supplier;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.SimpleTypeVisitor8;
+import javax.lang.model.util.Types;
+
+/**
+ * Generates implementations of {@link
+ * com.google.auto.value.extension.toprettystring.ToPrettyString} annotated methods in {@link
+ * com.google.auto.value.AutoValue} types.
+ */
+@AutoService(AutoValueExtension.class)
+public final class ToPrettyStringExtension extends AutoValueExtension {
+ private static final ImmutableSet<Modifier> INHERITED_VISIBILITY_MODIFIERS =
+ ImmutableSet.of(PUBLIC, PROTECTED);
+ private static final String INDENT = " ";
+ private static final String INDENT_METHOD_NAME = "$indent";
+ private static final CodeBlock KEY_VALUE_SEPARATOR = CodeBlock.of("$S", ": ");
+
+ @Override
+ public String generateClass(
+ Context context, String className, String classToExtend, boolean isFinal) {
+ TypeSpec type =
+ extensionClassTypeSpecBuilder(context, className, classToExtend, isFinal)
+ .addMethods(toPrettyStringMethodSpecs(context))
+ .build();
+ return JavaFile.builder(context.packageName(), type)
+ .skipJavaLangImports(true)
+ .build()
+ .toString();
+ }
+
+ private ImmutableList<MethodSpec> toPrettyStringMethodSpecs(Context context) {
+ ExecutableElement toPrettyStringMethod = getOnlyElement(toPrettyStringMethods(context));
+ MethodSpec.Builder method =
+ methodBuilder(toPrettyStringMethod.getSimpleName().toString())
+ .addAnnotation(Override.class)
+ .returns(ClassName.get(String.class))
+ .addModifiers(FINAL)
+ .addModifiers(
+ intersection(toPrettyStringMethod.getModifiers(), INHERITED_VISIBILITY_MODIFIERS));
+
+ method.addCode("return $S", context.autoValueClass().getSimpleName() + " {");
+ ToPrettyStringImplementation implementation = ToPrettyStringImplementation.create(context);
+ method.addCode(implementation.toStringCodeBlock.build());
+
+ if (!context.properties().isEmpty()) {
+ method.addCode(" + $S", "\n");
+ }
+ method.addCode(" + $S;\n", "}");
+
+ return ImmutableList.<MethodSpec>builder()
+ .add(method.build())
+ .addAll(implementation.delegateMethods.values())
+ .add(indentMethod())
+ .build();
+ }
+
+ private static MethodSpec indentMethod() {
+ return methodBuilder(INDENT_METHOD_NAME)
+ .addModifiers(PRIVATE, STATIC)
+ .returns(ClassName.get(String.class))
+ .addParameter(TypeName.INT, "level")
+ .addStatement("$1T builder = new $1T()", StringBuilder.class)
+ .beginControlFlow("for (int i = 0; i < level; i++)")
+ .addStatement("builder.append($S)", INDENT)
+ .endControlFlow()
+ .addStatement("return builder.toString()")
+ .build();
+ }
+
+ private static class ToPrettyStringImplementation {
+ private final Types types;
+ private final Elements elements;
+
+ private final CodeBlock.Builder toStringCodeBlock = CodeBlock.builder();
+ private final Map<Equivalence.Wrapper<TypeMirror>, MethodSpec> delegateMethods =
+ new LinkedHashMap<>();
+ private final Set<String> methodNames = new HashSet<>();
+
+ private ToPrettyStringImplementation(Context context) {
+ this.types = context.processingEnvironment().getTypeUtils();
+ this.elements = context.processingEnvironment().getElementUtils();
+ // do not submit: what about "inherited" static methods?
+ getLocalAndInheritedMethods(context.autoValueClass(), types, elements)
+ .forEach(method -> methodNames.add(method.getSimpleName().toString()));
+ }
+
+ static ToPrettyStringImplementation create(Context context) {
+ ToPrettyStringImplementation implemention = new ToPrettyStringImplementation(context);
+ context
+ .propertyTypes()
+ .forEach(
+ (propertyName, type) -> {
+ String methodName =
+ context.properties().get(propertyName).getSimpleName().toString();
+ implemention.toStringCodeBlock.add(
+ "\n + $S + $L + $S",
+ String.format("\n%s%s = ", INDENT, propertyName),
+ implemention.format(CodeBlock.of("$N()", methodName), CodeBlock.of("1"), type),
+ ",");
+ });
+ return implemention;
+ }
+
+ /**
+ * Returns {@code propertyAccess} formatted for use within the {@link
+ * com.google.auto.value.extension.toprettystring.ToPrettyString} implementation.
+ *
+ * <p>If a helper method is necessary for formatting, a {@link MethodSpec} will be added to
+ * {@link #delegateMethods}.
+ *
+ * @param propertyAccess a reference to the variable that should be formatted.
+ * @param indentAccess a reference to an {@code int} representing how many indent levels should
+ * be used for this property.
+ * @param type the type of the {@code propertyAccess}.
+ */
+ private CodeBlock format(CodeBlock propertyAccess, CodeBlock indentAccess, TypeMirror type) {
+ PrettyPrintableKind printableKind = type.accept(new KindVisitor(types, elements), null);
+ DelegateMethod delegateMethod = new DelegateMethod(propertyAccess, indentAccess);
+ switch (printableKind) {
+ case PRIMITIVE:
+ return propertyAccess;
+ case REGULAR_OBJECT:
+ return delegateMethod
+ .methodName("format")
+ .invocation(
+ elements.getTypeElement("java.lang.Object").asType(), () -> reindent("toString"));
+ case HAS_TO_PRETTY_STRING_METHOD:
+ ExecutableElement method =
+ toPrettyStringMethod(asTypeElement(type), types, elements).get();
+ return delegateMethod.invocation(type, () -> reindent(method.getSimpleName()));
+ case ARRAY:
+ TypeMirror componentType = MoreTypes.asArray(type).getComponentType();
+ return delegateMethod.invocation(type, () -> forEachLoopMethodBody(componentType));
+ case COLLECTION:
+ TypeMirror elementType =
+ getOnlyElement(resolvedTypeParameters(type, "java.util.Collection"));
+ return delegateMethod.invocation(
+ collectionOf(elementType), () -> forEachLoopMethodBody(elementType));
+ case IMMUTABLE_PRIMITIVE_ARRAY:
+ return delegateMethod.invocation(type, this::forLoopMethodBody);
+ case OPTIONAL:
+ case GUAVA_OPTIONAL:
+ TypeMirror optionalType = getOnlyElement(MoreTypes.asDeclared(type).getTypeArguments());
+ return delegateMethod.invocation(
+ type, () -> optionalMethodBody(optionalType, printableKind));
+ case MAP:
+ return formatMap(type, delegateMethod);
+ case MULTIMAP:
+ return formatMultimap(type, delegateMethod);
+ }
+ throw new AssertionError(printableKind);
+ }
+
+ private CodeBlock formatMap(TypeMirror type, DelegateMethod delegateMethod) {
+ ImmutableList<TypeMirror> typeParameters = resolvedTypeParameters(type, "java.util.Map");
+ TypeMirror keyType = typeParameters.get(0);
+ TypeMirror valueType = typeParameters.get(1);
+ return delegateMethod.invocation(
+ mapOf(keyType, valueType), () -> mapMethodBody(keyType, valueType));
+ }
+
+ private CodeBlock formatMultimap(TypeMirror type, DelegateMethod delegateMethod) {
+ ImmutableList<TypeMirror> typeParameters =
+ resolvedTypeParameters(type, "com.google.common.collect.Multimap");
+ TypeMirror keyType = typeParameters.get(0);
+ TypeMirror valueType = typeParameters.get(1);
+ return delegateMethod.invocation(
+ multimapOf(keyType, valueType),
+ () -> multimapMethodBody(keyType, collectionOf(valueType)));
+ }
+
+ /**
+ * Parameter object to simplify the branches of {@link #format(CodeBlock, CodeBlock,
+ * TypeMirror)} that call a delegate method.
+ */
+ private class DelegateMethod {
+
+ private final CodeBlock propertyAccess;
+ private final CodeBlock indentAccess;
+ private Optional<String> methodName = Optional.empty();
+
+ DelegateMethod(CodeBlock propertyAccess, CodeBlock indentAccess) {
+ this.propertyAccess = propertyAccess;
+ this.indentAccess = indentAccess;
+ }
+
+ DelegateMethod methodName(String methodName) {
+ this.methodName = Optional.of(methodName);
+ return this;
+ }
+
+ CodeBlock invocation(TypeMirror parameterType, Supplier<CodeBlock> methodBody) {
+ Equivalence.Wrapper<TypeMirror> key = MoreTypes.equivalence().wrap(parameterType);
+ // This doesn't use putIfAbsent because the methodBody supplier could recursively create
+ // new delegate methods. Map.putIfAbsent doesn't support reentrant calls.
+ if (!delegateMethods.containsKey(key)) {
+ delegateMethods.put(
+ key,
+ createMethod(
+ methodName.orElseGet(() -> newDelegateMethodName(parameterType)),
+ parameterType,
+ methodBody));
+ }
+ return CodeBlock.of(
+ "$N($L, $L)", delegateMethods.get(key).name, propertyAccess, indentAccess);
+ }
+
+ private String newDelegateMethodName(TypeMirror type) {
+ String prefix = "format" + nameForType(type);
+ String methodName = prefix;
+ for (int i = 2; !methodNames.add(methodName); i++) {
+ methodName = prefix + i;
+ }
+ return methodName;
+ }
+
+ private MethodSpec createMethod(
+ String methodName, TypeMirror type, Supplier<CodeBlock> methodBody) {
+ return methodBuilder(methodName)
+ .addModifiers(PRIVATE, STATIC)
+ .returns(ClassName.get(String.class))
+ .addParameter(TypeName.get(type), "value")
+ .addParameter(TypeName.INT, "indentLevel")
+ .beginControlFlow("if (value == null)")
+ .addStatement("return $S", "null")
+ .endControlFlow()
+ .addCode(methodBody.get())
+ .build();
+ }
+ }
+
+ private CodeBlock reindent(CharSequence methodName) {
+ return CodeBlock.builder()
+ .addStatement(
+ "return value.$1N().replace($2S, $2S + $3N(indentLevel))",
+ methodName,
+ "\n",
+ INDENT_METHOD_NAME)
+ .build();
+ }
+
+ private CodeBlock forEachLoopMethodBody(TypeMirror elementType) {
+ return loopMethodBody(
+ "[",
+ "]",
+ CodeBlock.of("for ($T element : value)", elementType),
+ format(CodeBlock.of("element"), CodeBlock.of("indentLevel + 1"), elementType));
+ }
+
+ private CodeBlock forLoopMethodBody() {
+ return loopMethodBody(
+ "[",
+ "]",
+ CodeBlock.of("for (int i = 0; i < value.length(); i++)"),
+ CodeBlock.of("value.get(i)"));
+ }
+
+ private CodeBlock mapMethodBody(TypeMirror keyType, TypeMirror valueType) {
+ return forEachMapEntryMethodBody(keyType, valueType, "value");
+ }
+
+ private CodeBlock multimapMethodBody(TypeMirror keyType, TypeMirror valueType) {
+ return forEachMapEntryMethodBody(keyType, valueType, "value.asMap()");
+ }
+
+ private CodeBlock forEachMapEntryMethodBody(
+ TypeMirror keyType, TypeMirror valueType, String propertyAccess) {
+ CodeBlock entryType = CodeBlock.of("$T<$T, $T>", Map.Entry.class, keyType, valueType);
+ return loopMethodBody(
+ "{",
+ "}",
+ CodeBlock.of("for ($L entry : $L.entrySet())", entryType, propertyAccess),
+ format(CodeBlock.of("entry.getKey()"), CodeBlock.of("indentLevel + 1"), keyType),
+ KEY_VALUE_SEPARATOR,
+ format(CodeBlock.of("entry.getValue()"), CodeBlock.of("indentLevel + 1"), valueType));
+ }
+
+ private CodeBlock loopMethodBody(
+ String openSymbol,
+ String closeSymbol,
+ CodeBlock loopDeclaration,
+ CodeBlock... appendedValues) {
+ ImmutableList<CodeBlock> allAppendedValues =
+ ImmutableList.<CodeBlock>builder()
+ .add(CodeBlock.of("$S", "\n"))
+ .add(CodeBlock.of("$N(indentLevel + 1)", INDENT_METHOD_NAME))
+ .add(appendedValues)
+ .add(CodeBlock.of("$S", ","))
+ .build();
+ return CodeBlock.builder()
+ .addStatement("$1T builder = new $1T().append($2S)", StringBuilder.class, openSymbol)
+ .addStatement("boolean hasElements = false")
+ .beginControlFlow("$L", loopDeclaration)
+ .addStatement(
+ "builder$L",
+ allAppendedValues.stream()
+ .map(value -> CodeBlock.of(".append($L)", value))
+ .collect(CodeBlock.joining("")))
+ .addStatement("hasElements = true")
+ .endControlFlow()
+ .beginControlFlow("if (hasElements)")
+ .addStatement("builder.append($S).append($N(indentLevel))", "\n", INDENT_METHOD_NAME)
+ .endControlFlow()
+ .addStatement("return builder.append($S).toString()", closeSymbol)
+ .build();
+ }
+
+ private CodeBlock optionalMethodBody(
+ TypeMirror optionalType, PrettyPrintableKind printableKind) {
+ return CodeBlock.builder()
+ .addStatement(
+ "return (value.isPresent() ? $L : $S)",
+ format(CodeBlock.of("value.get()"), CodeBlock.of("indentLevel"), optionalType),
+ printableKind.equals(PrettyPrintableKind.OPTIONAL) ? "<empty>" : "<absent>")
+ .build();
+ }
+
+ private ImmutableList<TypeMirror> resolvedTypeParameters(
+ TypeMirror propertyType, String interfaceName) {
+ return elements.getTypeElement(interfaceName).getTypeParameters().stream()
+ .map(p -> types.asMemberOf(MoreTypes.asDeclared(propertyType), p))
+ .collect(toImmutableList());
+ }
+
+ private DeclaredType collectionOf(TypeMirror elementType) {
+ return types.getDeclaredType(elements.getTypeElement("java.util.Collection"), elementType);
+ }
+
+ private DeclaredType mapOf(TypeMirror keyType, TypeMirror valueType) {
+ return types.getDeclaredType(elements.getTypeElement("java.util.Map"), keyType, valueType);
+ }
+
+ private DeclaredType multimapOf(TypeMirror keyType, TypeMirror valueType) {
+ return types.getDeclaredType(
+ elements.getTypeElement("com.google.common.collect.Multimap"), keyType, valueType);
+ }
+
+ /** Returns a valid Java identifier for method or variable of type {@code type}. */
+ private String nameForType(TypeMirror type) {
+ return type.accept(
+ new SimpleTypeVisitor8<String, Void>() {
+ @Override
+ public String visitDeclared(DeclaredType type, Void v) {
+ String simpleName = simpleNameForType(type);
+ if (type.getTypeArguments().isEmpty()) {
+ return simpleName;
+ }
+ ImmutableList<String> typeArgumentNames =
+ type.getTypeArguments().stream()
+ .map(t -> simpleNameForType(t))
+ .collect(toImmutableList());
+ if (isMapOrMultimap(type) && typeArgumentNames.size() == 2) {
+ return String.format(
+ "%sOf%sTo%s", simpleName, typeArgumentNames.get(0), typeArgumentNames.get(1));
+ }
+
+ List<String> parts = new ArrayList<>();
+ parts.add(simpleName);
+ parts.add("Of");
+ parts.addAll(typeArgumentNames.subList(0, typeArgumentNames.size() - 1));
+ if (typeArgumentNames.size() > 1) {
+ parts.add("And");
+ }
+ parts.add(getLast(typeArgumentNames));
+ return String.join("", parts);
+ }
+
+ @Override
+ protected String defaultAction(TypeMirror type, Void v) {
+ return simpleNameForType(type);
+ }
+ },
+ null);
+ }
+
+ boolean isMapOrMultimap(TypeMirror type) {
+ TypeMirror mapType = elements.getTypeElement("java.util.Map").asType();
+ if (types.isAssignable(type, types.erasure(mapType))) {
+ return true;
+ }
+ TypeElement multimapElement = elements.getTypeElement("com.google.common.collect.Multimap");
+ return multimapElement != null
+ && types.isAssignable(type, types.erasure(multimapElement.asType()));
+ }
+
+ private String simpleNameForType(TypeMirror type) {
+ return type.accept(
+ new SimpleTypeVisitor8<String, Void>() {
+ @Override
+ public String visitPrimitive(PrimitiveType primitiveType, Void v) {
+ return types.boxedClass(primitiveType).getSimpleName().toString();
+ }
+
+ @Override
+ public String visitArray(ArrayType arrayType, Void v) {
+ return arrayType.getComponentType().accept(this, null) + "Array";
+ }
+
+ @Override
+ public String visitDeclared(DeclaredType declaredType, Void v) {
+ return declaredType.asElement().getSimpleName().toString();
+ }
+
+ @Override
+ protected String defaultAction(TypeMirror typeMirror, Void v) {
+ throw new AssertionError(typeMirror);
+ }
+ },
+ null);
+ }
+ }
+
+ enum PrettyPrintableKind {
+ HAS_TO_PRETTY_STRING_METHOD,
+ REGULAR_OBJECT,
+ PRIMITIVE,
+ COLLECTION,
+ ARRAY,
+ IMMUTABLE_PRIMITIVE_ARRAY,
+ OPTIONAL,
+ GUAVA_OPTIONAL,
+ MAP,
+ MULTIMAP,
+ ;
+
+ private static final ImmutableMap<String, PrettyPrintableKind> KINDS_BY_EXACT_TYPE =
+ ImmutableMap.of(
+ "java.util.Optional", OPTIONAL,
+ "com.google.common.base.Optional", GUAVA_OPTIONAL,
+ "com.google.common.primitives.ImmutableIntArray", IMMUTABLE_PRIMITIVE_ARRAY,
+ "com.google.common.primitives.ImmutableLongArray", IMMUTABLE_PRIMITIVE_ARRAY,
+ "com.google.common.primitives.ImmutableDoubleArray", IMMUTABLE_PRIMITIVE_ARRAY);
+
+ private static final ImmutableMap<String, PrettyPrintableKind> KINDS_BY_SUPERTYPE =
+ ImmutableMap.of(
+ "java.util.Collection", COLLECTION,
+ "java.util.Map", MAP,
+ "com.google.common.collect.Multimap", MULTIMAP);
+
+ static class KindVisitor extends SimpleTypeVisitor8<PrettyPrintableKind, Void> {
+ private final Elements elements;
+ private final Types types;
+
+ KindVisitor(Types types, Elements elements) {
+ this.types = types;
+ this.elements = elements;
+ }
+
+ @Override
+ public PrettyPrintableKind visitPrimitive(PrimitiveType primitiveType, Void v) {
+ return PRIMITIVE;
+ }
+
+ @Override
+ public PrettyPrintableKind visitArray(ArrayType arrayType, Void v) {
+ return ARRAY;
+ }
+
+ @Override
+ public PrettyPrintableKind visitDeclared(DeclaredType declaredType, Void v) {
+ TypeElement typeElement = asTypeElement(declaredType);
+ if (toPrettyStringMethod(typeElement, types, elements).isPresent()) {
+ return HAS_TO_PRETTY_STRING_METHOD;
+ }
+ PrettyPrintableKind byExactType =
+ KINDS_BY_EXACT_TYPE.get(typeElement.getQualifiedName().toString());
+ if (byExactType != null) {
+ return byExactType;
+ }
+
+ for (Map.Entry<String, PrettyPrintableKind> entry : KINDS_BY_SUPERTYPE.entrySet()) {
+ TypeElement supertypeElement = elements.getTypeElement(entry.getKey());
+ if (supertypeElement != null
+ && types.isAssignable(declaredType, types.erasure(supertypeElement.asType()))) {
+ return entry.getValue();
+ }
+ }
+
+ return REGULAR_OBJECT;
+ }
+ }
+ }
+
+ @Override
+ public boolean applicable(Context context) {
+ return toPrettyStringMethods(context).size() == 1;
+ }
+
+ @Override
+ public ImmutableSet<ExecutableElement> consumeMethods(Context context) {
+ return toPrettyStringMethods(context);
+ }
+
+ @Override
+ public IncrementalExtensionType incrementalType(ProcessingEnvironment processingEnvironment) {
+ return IncrementalExtensionType.ISOLATING;
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringMethods.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringMethods.java
new file mode 100644
index 0000000..041a16d
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringMethods.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring.processor;
+
+import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.auto.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
+import static com.google.auto.value.extension.toprettystring.processor.Annotations.toPrettyStringAnnotation;
+import static com.google.common.collect.MoreCollectors.toOptional;
+
+import com.google.auto.value.extension.AutoValueExtension.Context;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.Optional;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+final class ToPrettyStringMethods {
+ /**
+ * Returns the {@link com.google.auto.value.extension.toprettystring.ToPrettyString} annotated
+ * methods for an {@code @AutoValue} type.
+ */
+ static ImmutableSet<ExecutableElement> toPrettyStringMethods(Context context) {
+ return context.abstractMethods().stream()
+ .filter(method -> toPrettyStringAnnotation(method).isPresent())
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Returns the {@link com.google.auto.value.extension.toprettystring.ToPrettyString} annotated
+ * method for a type.
+ */
+ static ImmutableList<ExecutableElement> toPrettyStringMethods(
+ TypeElement element, Types types, Elements elements) {
+ return getLocalAndInheritedMethods(element, types, elements).stream()
+ .filter(method -> toPrettyStringAnnotation(method).isPresent())
+ .collect(toImmutableList());
+ }
+
+ /**
+ * Returns the {@link com.google.auto.value.extension.toprettystring.ToPrettyString} annotated
+ * method for a type.
+ */
+ static Optional<ExecutableElement> toPrettyStringMethod(
+ TypeElement element, Types types, Elements elements) {
+ return toPrettyStringMethods(element, types, elements).stream().collect(toOptional());
+ }
+
+ private ToPrettyStringMethods() {}
+}
diff --git a/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringValidator.java b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringValidator.java
new file mode 100644
index 0000000..b77a54d
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/extension/toprettystring/processor/ToPrettyStringValidator.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring.processor;
+
+import static com.google.auto.value.extension.toprettystring.processor.ClassNames.TO_PRETTY_STRING_NAME;
+import static com.google.auto.value.extension.toprettystring.processor.ToPrettyStringMethods.toPrettyStringMethods;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toCollection;
+import static javax.lang.model.element.Modifier.STATIC;
+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.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType;
+
+/**
+ * An annotation processor that validates {@link
+ * com.google.auto.value.extension.toprettystring.ToPrettyString} usage.
+ */
+@AutoService(Processor.class)
+@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.ISOLATING)
+@SupportedAnnotationTypes(TO_PRETTY_STRING_NAME)
+public final class ToPrettyStringValidator extends AbstractProcessor {
+ @Override
+ public boolean process(
+ Set<? extends TypeElement> annotations, RoundEnvironment roundEnvironment) {
+ Types types = processingEnv.getTypeUtils();
+ Elements elements = processingEnv.getElementUtils();
+ TypeElement toPrettyString = elements.getTypeElement(TO_PRETTY_STRING_NAME);
+
+ Set<ExecutableElement> annotatedMethods =
+ methodsIn(roundEnvironment.getElementsAnnotatedWith(toPrettyString));
+ for (ExecutableElement method : annotatedMethods) {
+ validateMethod(method, elements);
+ }
+
+ validateSingleToPrettyStringMethod(annotatedMethods, types, elements);
+
+ return false;
+ }
+
+ private void validateMethod(ExecutableElement method, Elements elements) {
+ ErrorReporter errorReporter = new ErrorReporter(method, processingEnv.getMessager());
+ if (method.getModifiers().contains(STATIC)) {
+ errorReporter.reportError("@ToPrettyString methods must be instance methods");
+ }
+
+ TypeMirror stringType = elements.getTypeElement("java.lang.String").asType();
+ if (!MoreTypes.equivalence().equivalent(method.getReturnType(), stringType)) {
+ errorReporter.reportError("@ToPrettyString methods must return String");
+ }
+
+ if (!method.getParameters().isEmpty()) {
+ errorReporter.reportError("@ToPrettyString methods cannot have parameters");
+ }
+ }
+
+ private void validateSingleToPrettyStringMethod(
+ Set<ExecutableElement> annotatedMethods, Types types, Elements elements) {
+ Set<TypeElement> enclosingTypes =
+ annotatedMethods.stream()
+ .map(Element::getEnclosingElement)
+ .map(MoreElements::asType)
+ .collect(toCollection(LinkedHashSet::new));
+ for (TypeElement enclosingType : enclosingTypes) {
+ ImmutableList<ExecutableElement> methods =
+ toPrettyStringMethods(enclosingType, types, elements);
+ if (methods.size() > 1) {
+ processingEnv
+ .getMessager()
+ .printMessage(
+ ERROR,
+ String.format(
+ "%s has multiple @ToPrettyString methods:%s",
+ enclosingType.getQualifiedName(), formatMethodList(methods)),
+ enclosingType);
+ }
+ }
+ }
+
+ private String formatMethodList(ImmutableList<ExecutableElement> methods) {
+ return methods.stream().map(this::formatMethodInList).collect(joining());
+ }
+
+ private String formatMethodInList(ExecutableElement method) {
+ return String.format(
+ "\n - %s.%s()",
+ MoreElements.asType(method.getEnclosingElement()).getQualifiedName(),
+ method.getSimpleName());
+ }
+
+ @Override
+ public SourceVersion getSupportedSourceVersion() {
+ return SourceVersion.latestSupported();
+ }
+
+ private static final class ErrorReporter {
+ private final ExecutableElement method;
+ private final Messager messager;
+
+ ErrorReporter(ExecutableElement method, Messager messager) {
+ this.method = method;
+ this.messager = messager;
+ }
+
+ void reportError(String error) {
+ messager.printMessage(ERROR, error, method);
+ }
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java
index d3cd9bd..3acf933 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoAnnotationProcessor.java
@@ -17,14 +17,20 @@
import static com.google.auto.common.GeneratedAnnotations.generatedAnnotation;
import static com.google.auto.value.processor.ClassNames.AUTO_ANNOTATION_NAME;
+import static com.google.common.collect.Maps.immutableEntry;
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.joining;
import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
import com.google.auto.common.SuperficialValidation;
import com.google.auto.service.AutoService;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import com.google.common.hash.Hashing;
import com.google.common.primitives.Primitives;
import com.google.errorprone.annotations.FormatMethod;
import java.io.IOException;
@@ -41,6 +47,7 @@
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
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.ElementKind;
@@ -74,11 +81,30 @@
public class AutoAnnotationProcessor extends AbstractProcessor {
public AutoAnnotationProcessor() {}
+ private Elements elementUtils;
+ private Types typeUtils;
+ private Nullables nullables;
+ private TypeMirror javaLangObject;
+
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
+ @Override
+ public ImmutableSet<String> getSupportedOptions() {
+ return ImmutableSet.of(Nullables.NULLABLE_OPTION);
+ }
+
+ @Override
+ public synchronized void init(ProcessingEnvironment processingEnv) {
+ super.init(processingEnv);
+ this.elementUtils = processingEnv.getElementUtils();
+ this.typeUtils = processingEnv.getTypeUtils();
+ this.nullables = new Nullables(processingEnv);
+ this.javaLangObject = elementUtils.getTypeElement("java.lang.Object").asType();
+ }
+
/**
* Issue a compilation error. This method does not throw an exception, since we want to continue
* processing and perhaps report other errors.
@@ -99,26 +125,10 @@
return new AbortProcessingException();
}
- private Elements elementUtils;
- private Types typeUtils;
-
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
- elementUtils = processingEnv.getElementUtils();
- typeUtils = processingEnv.getTypeUtils();
- boolean claimed =
- (annotations.size() == 1
- && annotations
- .iterator()
- .next()
- .getQualifiedName()
- .contentEquals(AUTO_ANNOTATION_NAME));
- if (claimed) {
- process(roundEnv);
- return true;
- } else {
- return false;
- }
+ process(roundEnv);
+ return false;
}
private void process(RoundEnvironment roundEnv) {
@@ -152,7 +162,7 @@
Set<Class<?>> wrapperTypesUsedInCollections = wrapperTypesUsedInCollections(method);
ImmutableMap<String, ExecutableElement> memberMethods = getMemberMethods(annotationElement);
- TypeElement methodClass = (TypeElement) method.getEnclosingElement();
+ TypeElement methodClass = MoreElements.asType(method.getEnclosingElement());
String pkg = TypeSimplifier.packageNameOf(methodClass);
ImmutableMap<String, AnnotationValue> defaultValues = getDefaultValues(annotationElement);
@@ -169,9 +179,11 @@
vars.generated = getGeneratedTypeName();
vars.members = members;
vars.params = parameters;
+ vars.equalsParameterType = equalsParameterType();
vars.pkg = pkg;
vars.wrapperTypesUsedInCollections = wrapperTypesUsedInCollections;
vars.gwtCompatible = isGwtCompatible(annotationElement);
+ vars.serialVersionUID = computeSerialVersionUid(members, parameters);
ImmutableMap<String, Integer> invariableHashes = invariableHashes(members, parameters.keySet());
vars.invariableHashSum = 0;
for (int h : invariableHashes.values()) {
@@ -191,6 +203,18 @@
.orElse("");
}
+ private String equalsParameterType() {
+ // Unlike AutoValue, we don't currently try to guess a @Nullable based on the methods in your
+ // class. It's the default one or nothing.
+ ImmutableList<AnnotationMirror> equalsParameterAnnotations =
+ nullables
+ .appropriateNullableGivenMethods(ImmutableSet.of())
+ .map(ImmutableList::of)
+ .orElse(ImmutableList.of());
+ return TypeEncoder.encodeWithAnnotations(
+ javaLangObject, equalsParameterAnnotations, ImmutableSet.of());
+ }
+
/**
* Returns the hashCode of the given AnnotationValue, if that hashCode is guaranteed to be always
* the same. The hashCode of a String or primitive type never changes. The hashCode of a Class or
@@ -246,7 +270,7 @@
private boolean methodsAreOverloaded(List<ExecutableElement> methods) {
boolean overloaded = false;
- Set<String> classNames = new HashSet<String>();
+ Set<String> classNames = new HashSet<>();
for (ExecutableElement method : methods) {
String qualifiedClassName =
fullyQualifiedName(
@@ -261,10 +285,10 @@
}
private String generatedClassName(ExecutableElement method) {
- TypeElement type = (TypeElement) method.getEnclosingElement();
+ TypeElement type = MoreElements.asType(method.getEnclosingElement());
String name = type.getSimpleName().toString();
while (type.getEnclosingElement() instanceof TypeElement) {
- type = (TypeElement) type.getEnclosingElement();
+ type = MoreElements.asType(type.getEnclosingElement());
name = type.getSimpleName() + "_" + name;
}
return "AutoAnnotation_" + name + "_" + method.getSimpleName();
@@ -275,7 +299,7 @@
if (returnTypeMirror.getKind() == TypeKind.DECLARED) {
Element returnTypeElement = typeUtils.asElement(method.getReturnType());
if (returnTypeElement.getKind() == ElementKind.ANNOTATION_TYPE) {
- return (TypeElement) returnTypeElement;
+ return MoreElements.asType(returnTypeElement);
}
}
throw abortWithError(
@@ -399,7 +423,7 @@
if (memberType.getKind() != TypeKind.ARRAY) {
return false;
}
- TypeMirror arrayElementType = ((ArrayType) memberType).getComponentType();
+ TypeMirror arrayElementType = MoreTypes.asArray(memberType).getComponentType();
TypeMirror wrappedArrayElementType =
arrayElementType.getKind().isPrimitive()
? typeUtils.boxedClass((PrimitiveType) arrayElementType).asType()
@@ -416,7 +440,7 @@
* like {@code List<Integer>}. This is needed because we will emit a helper method for each such
* type, for example to convert {@code Collection<Integer>} into {@code int[]}.
*/
- private Set<Class<?>> wrapperTypesUsedInCollections(ExecutableElement method) {
+ private ImmutableSet<Class<?>> wrapperTypesUsedInCollections(ExecutableElement method) {
TypeElement javaUtilCollection = elementUtils.getTypeElement(Collection.class.getName());
ImmutableSet.Builder<Class<?>> usedInCollections = ImmutableSet.builder();
for (Class<?> wrapper : Primitives.allWrapperTypes()) {
@@ -437,9 +461,7 @@
}
private static boolean isGwtCompatible(TypeElement annotationElement) {
- return annotationElement
- .getAnnotationMirrors()
- .stream()
+ return annotationElement.getAnnotationMirrors().stream()
.map(mirror -> mirror.getAnnotationType().asElement())
.anyMatch(element -> element.getSimpleName().contentEquals("GwtCompatible"));
}
@@ -448,6 +470,43 @@
return pkg.isEmpty() ? cls : pkg + "." + cls;
}
+ /**
+ * We compute a {@code serialVersionUID} for the generated class based on the names and types of
+ * the annotation members that the {@code @AutoAnnotation} method defines. These are exactly the
+ * names and types of the instance fields in the generated class. So in the common case where the
+ * annotation acquires a new member with a default value, if the {@code @AutoAnnotation} method is
+ * not changed then the generated class will acquire an implementation of the new member method
+ * which just returns the default value. The {@code serialVersionUID} will not change, which makes
+ * sense because the instance fields haven't changed, and instances that were serialized before
+ * the new member was added should deserialize fine. On the other hand, if you then add a
+ * parameter to the {@code @AutoAnnotation} method for the new member, the implementation class
+ * will acquire a new instance field, and we will compute a different {@code serialVersionUID}.
+ * That's because an instance serialized before that change would not have a value for the new
+ * instance field, which would end up zero or null. Users don't expect annotation methods to
+ * return null so that would be bad.
+ *
+ * <p>We could instead add a {@code readObject(ObjectInputStream)} method that would check that
+ * all of the instance fields are really present in the deserialized instance, and perhaps
+ * replace them with their default values from the annotation if not. That seems a lot more
+ * complicated than is justified, though, especially since the instance fields are final and
+ * would have to be set in the deserialized object through reflection.
+ */
+ private static long computeSerialVersionUid(
+ ImmutableMap<String, Member> members, ImmutableMap<String, Parameter> parameters) {
+ // TypeMirror.toString() isn't fully specified so it could potentially differ between
+ // implementations. Our member.getType() string comes from TypeEncoder and is predictable, but
+ // it includes `...` markers around fully-qualified type names, which are used to handle
+ // imports. So we remove those markers below.
+ String namesAndTypesString =
+ members.entrySet().stream()
+ .filter(e -> parameters.containsKey(e.getKey()))
+ .map(e -> immutableEntry(e.getKey(), e.getValue().getType().replace("`", "")))
+ .sorted(comparing(Map.Entry::getKey))
+ .map(e -> e.getKey() + ":" + e.getValue())
+ .collect(joining(";"));
+ return Hashing.murmur3_128().hashUnencodedChars(namesAndTypesString).asLong();
+ }
+
private void writeSourceFile(String className, String text, TypeElement originatingType) {
try {
JavaFileObject sourceFile =
@@ -491,7 +550,7 @@
public String getComponentType() {
Preconditions.checkState(getTypeMirror().getKind() == TypeKind.ARRAY);
- ArrayType arrayType = (ArrayType) getTypeMirror();
+ ArrayType arrayType = MoreTypes.asArray(getTypeMirror());
return TypeEncoder.encode(arrayType.getComponentType());
}
@@ -513,12 +572,12 @@
if (getTypeMirror().getKind() != TypeKind.ARRAY) {
return false;
}
- TypeMirror componentType = ((ArrayType) getTypeMirror()).getComponentType();
+ TypeMirror componentType = MoreTypes.asArray(getTypeMirror()).getComponentType();
if (componentType.getKind() != TypeKind.DECLARED) {
return false;
}
- DeclaredType declared = (DeclaredType) componentType;
- if (!((TypeElement) processingEnv.getTypeUtils().asElement(componentType))
+ DeclaredType declared = MoreTypes.asDeclared(componentType);
+ if (!MoreElements.asType(processingEnv.getTypeUtils().asElement(componentType))
.getQualifiedName()
.contentEquals("java.lang.Class")) {
return false;
@@ -530,7 +589,7 @@
if (parameter.getKind() != TypeKind.WILDCARD) {
return true; // for Class<Foo>
}
- WildcardType wildcard = (WildcardType) parameter;
+ WildcardType wildcard = MoreTypes.asWildcard(parameter);
// In theory, we should check if getExtendsBound() != Object, since '?' is equivalent to
// '? extends Object', but, experimentally, neither javac or ecj will sets getExtendsBound()
// to 'Object', so there isn't a point in checking.
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoAnnotationTemplateVars.java b/value/src/main/java/com/google/auto/value/processor/AutoAnnotationTemplateVars.java
index 4db59c7..11bc896 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoAnnotationTemplateVars.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoAnnotationTemplateVars.java
@@ -35,6 +35,12 @@
*/
Map<String, AutoAnnotationProcessor.Parameter> params;
+ /**
+ * A string representing the parameter type declaration of the equals(Object) method, including
+ * any annotations.
+ */
+ String equalsParameterType;
+
/** The encoded form of the {@code Generated} class, or empty if it is not available. */
String generated;
@@ -74,6 +80,12 @@
/** The sum of the hash code contributions from the members in {@link #invariableHashes}. */
Integer invariableHashSum;
+ /**
+ * A computed {@code serialVersionUID} based on the names and types of the {@code @AutoAnnotation}
+ * method parameters.
+ */
+ Long serialVersionUID;
+
private static final Template TEMPLATE = parsedTemplateForResource("autoannotation.vm");
@Override
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoBuilderProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoBuilderProcessor.java
new file mode 100644
index 0000000..b6a578f
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/AutoBuilderProcessor.java
@@ -0,0 +1,417 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.auto.common.MoreElements.getPackage;
+import static com.google.auto.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
+import static com.google.auto.value.processor.AutoValueProcessor.OMIT_IDENTIFIERS_OPTION;
+import static com.google.auto.value.processor.ClassNames.AUTO_BUILDER_NAME;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toCollection;
+import static java.util.stream.Collectors.toMap;
+import static javax.lang.model.util.ElementFilter.constructorsIn;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.auto.common.AnnotationValues;
+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.processor.BuilderSpec.PropertyGetter;
+import com.google.auto.value.processor.MissingTypes.MissingTypeException;
+import com.google.common.base.Ascii;
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Map;
+import java.util.NavigableSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Stream;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType;
+
+/**
+ * Javac annotation processor (compiler plugin) for builders; user code never references this class.
+ *
+ * @see <a href="https://github.com/google/auto/tree/master/value">AutoValue User's Guide</a>
+ * @author Éamonn McManus
+ */
+@AutoService(Processor.class)
+@SupportedAnnotationTypes(AUTO_BUILDER_NAME)
+@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.ISOLATING)
+public class AutoBuilderProcessor extends AutoValueishProcessor {
+ private static final String ALLOW_OPTION = "com.google.auto.value.AutoBuilderIsUnstable";
+
+ public AutoBuilderProcessor() {
+ super(AUTO_BUILDER_NAME);
+ }
+
+ @Override
+ public Set<String> getSupportedOptions() {
+ return ImmutableSet.of(OMIT_IDENTIFIERS_OPTION, ALLOW_OPTION);
+ }
+
+ private TypeMirror javaLangVoid;
+
+ @Override
+ public synchronized void init(ProcessingEnvironment processingEnv) {
+ super.init(processingEnv);
+ javaLangVoid = elementUtils().getTypeElement("java.lang.Void").asType();
+ }
+
+ @Override
+ void processType(TypeElement autoBuilderType) {
+ if (!processingEnv.getOptions().containsKey(ALLOW_OPTION)) {
+ errorReporter()
+ .abortWithError(
+ autoBuilderType,
+ "Compile with -A%s to enable this UNSUPPORTED AND UNSTABLE prototype",
+ ALLOW_OPTION);
+ }
+ if (autoBuilderType.getKind() != ElementKind.CLASS
+ && autoBuilderType.getKind() != ElementKind.INTERFACE) {
+ errorReporter()
+ .abortWithError(
+ autoBuilderType,
+ "[AutoBuilderWrongType] @AutoBuilder only applies to classes and interfaces");
+ }
+ checkModifiersIfNested(autoBuilderType);
+ // The annotation is guaranteed to be present by the contract of Processor#process
+ AnnotationMirror autoBuilderAnnotation =
+ getAnnotationMirror(autoBuilderType, AUTO_BUILDER_NAME).get();
+ TypeElement ofClass = getOfClass(autoBuilderType, autoBuilderAnnotation);
+ checkModifiersIfNested(ofClass, autoBuilderType, "AutoBuilder ofClass");
+ String callMethod = findCallMethodValue(autoBuilderAnnotation);
+ ImmutableSet<ExecutableElement> methods =
+ abstractMethodsIn(
+ getLocalAndInheritedMethods(autoBuilderType, typeUtils(), elementUtils()));
+ ExecutableElement executable = findExecutable(ofClass, callMethod, autoBuilderType, methods);
+ BuilderSpec builderSpec = new BuilderSpec(ofClass, processingEnv, errorReporter());
+ BuilderSpec.Builder builder = builderSpec.new Builder(autoBuilderType);
+ TypeMirror builtType = builtType(executable);
+ Optional<BuilderMethodClassifier<VariableElement>> maybeClassifier =
+ BuilderMethodClassifierForAutoBuilder.classify(
+ methods, errorReporter(), processingEnv, executable, builtType, autoBuilderType);
+ if (!maybeClassifier.isPresent()) {
+ // We've already output one or more error messages.
+ return;
+ }
+ BuilderMethodClassifier<VariableElement> classifier = maybeClassifier.get();
+ Map<String, String> propertyToGetterName =
+ Maps.transformValues(classifier.builderGetters(), PropertyGetter::getName);
+ AutoBuilderTemplateVars vars = new AutoBuilderTemplateVars();
+ vars.props = propertySet(executable, propertyToGetterName);
+ builder.defineVars(vars, classifier);
+ vars.identifiers = !processingEnv.getOptions().containsKey(OMIT_IDENTIFIERS_OPTION);
+ String generatedClassName = generatedClassName(autoBuilderType, "AutoBuilder_");
+ vars.builderName = TypeSimplifier.simpleNameOf(generatedClassName);
+ vars.builtType = TypeEncoder.encode(builtType);
+ vars.build = build(executable);
+ vars.types = typeUtils();
+ vars.toBuilderConstructor = false;
+ vars.toBuilderMethods = ImmutableList.of();
+ defineSharedVarsForType(autoBuilderType, ImmutableSet.of(), vars);
+ String text = vars.toText();
+ text = TypeEncoder.decode(text, processingEnv, vars.pkg, autoBuilderType.asType());
+ text = Reformatter.fixup(text);
+ writeSourceFile(generatedClassName, text, autoBuilderType);
+ }
+
+ private ImmutableSet<Property> propertySet(
+ ExecutableElement executable, Map<String, String> propertyToGetterName) {
+ // Fix any parameter names that are reserved words in Java. Java source code can't have
+ // such parameter names, but Kotlin code might, for example.
+ Map<VariableElement, String> identifiers =
+ executable.getParameters().stream()
+ .collect(toMap(v -> v, v -> v.getSimpleName().toString()));
+ fixReservedIdentifiers(identifiers);
+ return executable.getParameters().stream()
+ .map(
+ v ->
+ newProperty(
+ v, identifiers.get(v), propertyToGetterName.get(v.getSimpleName().toString())))
+ .collect(toImmutableSet());
+ }
+
+ private Property newProperty(VariableElement var, String identifier, String getterName) {
+ String name = var.getSimpleName().toString();
+ TypeMirror type = var.asType();
+ Optional<String> nullableAnnotation = nullableAnnotationFor(var, var.asType());
+ return new Property(
+ name, identifier, TypeEncoder.encode(type), type, nullableAnnotation, getterName);
+ }
+
+ private ExecutableElement findExecutable(
+ TypeElement ofClass,
+ String callMethod,
+ TypeElement autoBuilderType,
+ ImmutableSet<ExecutableElement> methods) {
+ List<ExecutableElement> executables =
+ findRelevantExecutables(ofClass, callMethod, autoBuilderType);
+ String description =
+ callMethod.isEmpty() ? "constructor" : "static method named \"" + callMethod + "\"";
+ switch (executables.size()) {
+ case 0:
+ throw errorReporter()
+ .abortWithError(
+ autoBuilderType,
+ "[AutoBuilderNoVisible] No visible %s for %s",
+ description,
+ ofClass);
+ case 1:
+ return executables.get(0);
+ default:
+ return matchingExecutable(autoBuilderType, executables, methods, description);
+ }
+ }
+
+ private ImmutableList<ExecutableElement> findRelevantExecutables(
+ TypeElement ofClass, String callMethod, TypeElement autoBuilderType) {
+ List<? extends Element> elements = ofClass.getEnclosedElements();
+ Stream<ExecutableElement> relevantExecutables =
+ callMethod.isEmpty()
+ ? constructorsIn(elements).stream()
+ : methodsIn(elements).stream()
+ .filter(m -> m.getSimpleName().contentEquals(callMethod))
+ .filter(m -> m.getModifiers().contains(Modifier.STATIC));
+ return relevantExecutables
+ .filter(c -> visibleFrom(c, getPackage(autoBuilderType)))
+ .collect(toImmutableList());
+ }
+
+ private ExecutableElement matchingExecutable(
+ TypeElement autoBuilderType,
+ List<ExecutableElement> executables,
+ ImmutableSet<ExecutableElement> methods,
+ String description) {
+ // There's more than one visible executable (constructor or method). We try to find the one that
+ // corresponds to the methods in the @AutoBuilder interface. This is a bit approximate. We're
+ // basically just looking for an executable where all the parameter names correspond to setters
+ // or property builders in the interface. We might find out after choosing one that it is wrong
+ // for whatever reason (types don't match, spurious methods, etc). But it is likely that if the
+ // names are all accounted for in the methods, and if there's no other matching executable with
+ // more parameters, then this is indeed the one we want. If we later get errors when we try to
+ // analyze the interface in detail, those are probably legitimate errors and not because we
+ // picked the wrong executable.
+ ImmutableList<ExecutableElement> matches =
+ executables.stream().filter(x -> executableMatches(x, methods)).collect(toImmutableList());
+ switch (matches.size()) {
+ case 0:
+ throw errorReporter()
+ .abortWithError(
+ autoBuilderType,
+ "[AutoBuilderNoMatch] Property names do not correspond to the parameter names of"
+ + " any %s:\n%s",
+ description,
+ executableListString(executables));
+ case 1:
+ return matches.get(0);
+ default:
+ // More than one match, let's see if we can find the best one.
+ }
+ int max = matches.stream().mapToInt(c -> c.getParameters().size()).max().getAsInt();
+ ImmutableList<ExecutableElement> maxMatches =
+ matches.stream().filter(c -> c.getParameters().size() == max).collect(toImmutableList());
+ if (maxMatches.size() > 1) {
+ throw errorReporter()
+ .abortWithError(
+ autoBuilderType,
+ "[AutoBuilderAmbiguous] Property names correspond to more than one %s:\n%s",
+ description,
+ executableListString(maxMatches));
+ }
+ return maxMatches.get(0);
+ }
+
+ private String executableListString(List<ExecutableElement> executables) {
+ return executables.stream()
+ .map(AutoBuilderProcessor::executableString)
+ .collect(joining("\n ", " ", ""));
+ }
+
+ static String executableString(ExecutableElement executable) {
+ Element nameSource =
+ executable.getKind() == ElementKind.CONSTRUCTOR
+ ? executable.getEnclosingElement()
+ : executable;
+ return nameSource.getSimpleName()
+ + executable.getParameters().stream()
+ .map(v -> v.asType() + " " + v.getSimpleName())
+ .collect(joining(", ", "(", ")"));
+ }
+
+ private boolean executableMatches(
+ ExecutableElement executable, ImmutableSet<ExecutableElement> methods) {
+ // Start with the complete set of parameter names and remove them one by one as we find
+ // corresponding methods. We ignore case, under the assumption that it is unlikely that a case
+ // difference is going to allow a candidate to match when another one is better.
+ // A parameter named foo could be matched by methods like this:
+ // X foo(Y)
+ // X setFoo(Y)
+ // X fooBuilder()
+ // X fooBuilder(Y)
+ // There are further constraints, including on the types X and Y, that will later be imposed by
+ // BuilderMethodClassifier, but here we just require that there be at least one method with
+ // one of these shapes for foo.
+ NavigableSet<String> parameterNames =
+ executable.getParameters().stream()
+ .map(v -> v.getSimpleName().toString())
+ .collect(toCollection(() -> new TreeSet<>(String.CASE_INSENSITIVE_ORDER)));
+ for (ExecutableElement method : methods) {
+ String name = method.getSimpleName().toString();
+ if (name.endsWith("Builder")) {
+ String property = name.substring(0, name.length() - "Builder".length());
+ parameterNames.remove(property);
+ }
+ if (method.getParameters().size() == 1) {
+ parameterNames.remove(name);
+ if (name.startsWith("set")) {
+ parameterNames.remove(name.substring(3));
+ }
+ }
+ if (parameterNames.isEmpty()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean visibleFrom(Element element, PackageElement fromPackage) {
+ Visibility visibility = Visibility.effectiveVisibilityOfElement(element);
+ switch (visibility) {
+ case PUBLIC:
+ return true;
+ case PROTECTED:
+ // We care about whether the constructor is visible from the generated class. The generated
+ // class is never going to be a subclass of the class containing the constructor, so
+ // protected and default access are equivalent.
+ case DEFAULT:
+ return getPackage(element).equals(fromPackage);
+ default:
+ return false;
+ }
+ }
+
+ private TypeMirror builtType(ExecutableElement executable) {
+ switch (executable.getKind()) {
+ case CONSTRUCTOR:
+ return executable.getEnclosingElement().asType();
+ case METHOD:
+ return executable.getReturnType();
+ default:
+ throw new VerifyException("Unexpected executable kind " + executable.getKind());
+ }
+ }
+
+ private String build(ExecutableElement executable) {
+ TypeElement enclosing = MoreElements.asType(executable.getEnclosingElement());
+ String type = TypeEncoder.encodeRaw(enclosing.asType());
+ switch (executable.getKind()) {
+ case CONSTRUCTOR:
+ boolean generic = !enclosing.getTypeParameters().isEmpty();
+ String typeParams = generic ? "<>" : "";
+ return "new " + type + typeParams;
+ case METHOD:
+ return type + "." + executable.getSimpleName();
+ default:
+ throw new VerifyException("Unexpected executable kind " + executable.getKind());
+ }
+ }
+
+ private static final ElementKind ELEMENT_KIND_RECORD = elementKindRecord();
+
+ private static ElementKind elementKindRecord() {
+ try {
+ Field record = ElementKind.class.getField("RECORD");
+ return (ElementKind) record.get(null);
+ } catch (ReflectiveOperationException e) {
+ // OK: we must be on a JDK version that predates this.
+ return null;
+ }
+ }
+
+ private TypeElement getOfClass(
+ TypeElement autoBuilderType, AnnotationMirror autoBuilderAnnotation) {
+ TypeElement ofClassValue = findOfClassValue(autoBuilderAnnotation);
+ boolean isDefault = typeUtils().isSameType(ofClassValue.asType(), javaLangVoid);
+ if (!isDefault) {
+ return ofClassValue;
+ }
+ Element enclosing = autoBuilderType.getEnclosingElement();
+ ElementKind enclosingKind = enclosing.getKind();
+ if (enclosing.getKind() != ElementKind.CLASS && enclosingKind != ELEMENT_KIND_RECORD) {
+ errorReporter()
+ .abortWithError(
+ autoBuilderType,
+ "[AutoBuilderEnclosing] @AutoBuilder must specify ofClass=Something.class or it"
+ + " must be nested inside the class to be built; actually nested inside %s %s.",
+ Ascii.toLowerCase(enclosingKind.name()),
+ enclosing);
+ }
+ return MoreElements.asType(enclosing);
+ }
+
+ private TypeElement findOfClassValue(AnnotationMirror autoBuilderAnnotation) {
+ AnnotationValue ofClassValue =
+ AnnotationMirrors.getAnnotationValue(autoBuilderAnnotation, "ofClass");
+ Object value = ofClassValue.getValue();
+ if (value instanceof TypeMirror) {
+ TypeMirror ofClassType = (TypeMirror) value;
+ switch (ofClassType.getKind()) {
+ case DECLARED:
+ return MoreTypes.asTypeElement(ofClassType);
+ case ERROR:
+ throw new MissingTypeException(MoreTypes.asError(ofClassType));
+ default:
+ break;
+ }
+ }
+ throw new MissingTypeException(null);
+ }
+
+ private String findCallMethodValue(AnnotationMirror autoBuilderAnnotation) {
+ AnnotationValue callMethodValue =
+ AnnotationMirrors.getAnnotationValue(autoBuilderAnnotation, "callMethod");
+ return AnnotationValues.getString(callMethodValue);
+ }
+
+ @Override
+ Optional<String> nullableAnnotationForMethod(ExecutableElement propertyMethod) {
+ // TODO(b/183005059): implement
+ return Optional.empty();
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoBuilderTemplateVars.java b/value/src/main/java/com/google/auto/value/processor/AutoBuilderTemplateVars.java
new file mode 100644
index 0000000..8c08a48
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/AutoBuilderTemplateVars.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import com.google.escapevelocity.Template;
+
+class AutoBuilderTemplateVars extends AutoValueOrBuilderTemplateVars {
+ private static final Template TEMPLATE = parsedTemplateForResource("autobuilder.vm");
+
+ @Override
+ Template parsedTemplate() {
+ return TEMPLATE;
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java
index d73c1c2..711b138 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoOneOfProcessor.java
@@ -58,7 +58,7 @@
@AutoService(Processor.class)
@SupportedAnnotationTypes(AUTO_ONE_OF_NAME)
@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.ISOLATING)
-public class AutoOneOfProcessor extends AutoValueOrOneOfProcessor {
+public class AutoOneOfProcessor extends AutoValueishProcessor {
public AutoOneOfProcessor() {
super(AUTO_ONE_OF_NAME);
}
@@ -69,6 +69,11 @@
}
@Override
+ public ImmutableSet<String> getSupportedOptions() {
+ return ImmutableSet.of(Nullables.NULLABLE_OPTION);
+ }
+
+ @Override
void processType(TypeElement autoOneOfType) {
if (autoOneOfType.getKind() != ElementKind.CLASS) {
errorReporter()
@@ -123,19 +128,9 @@
}
private DeclaredType mirrorForKindType(TypeElement autoOneOfType) {
- Optional<AnnotationMirror> oneOfAnnotation =
- getAnnotationMirror(autoOneOfType, AUTO_ONE_OF_NAME);
- if (!oneOfAnnotation.isPresent()) {
- // This shouldn't happen unless the compilation environment is buggy,
- // but it has happened in the past and can crash the compiler.
- errorReporter()
- .abortWithError(
- autoOneOfType,
- "[AutoOneOfCompilerBug] annotation processor for @AutoOneOf was invoked with a type"
- + " that does not have that annotation; this is probably a compiler bug");
- }
- AnnotationValue kindValue =
- AnnotationMirrors.getAnnotationValue(oneOfAnnotation.get(), "value");
+ // The annotation is guaranteed to be present by the contract of Processor#process
+ AnnotationMirror oneOfAnnotation = getAnnotationMirror(autoOneOfType, AUTO_ONE_OF_NAME).get();
+ AnnotationValue kindValue = AnnotationMirrors.getAnnotationValue(oneOfAnnotation, "value");
Object value = kindValue.getValue();
if (value instanceof TypeMirror) {
TypeMirror kindType = (TypeMirror) value;
@@ -162,9 +157,7 @@
Map<String, String> transformedPropertyNames =
propertyNames.stream().collect(toMap(this::transformName, s -> s));
Map<String, Element> transformedEnumConstants =
- kindElement
- .getEnclosedElements()
- .stream()
+ kindElement.getEnclosedElements().stream()
.filter(e -> e.getKind().equals(ElementKind.ENUM_CONSTANT))
.collect(toMap(e -> transformName(e.getSimpleName().toString()), e -> e));
@@ -215,8 +208,7 @@
TypeMirror kindMirror,
ImmutableSet<ExecutableElement> abstractMethods) {
Set<ExecutableElement> kindGetters =
- abstractMethods
- .stream()
+ abstractMethods.stream()
.filter(e -> sameType(kindMirror, e.getReturnType()))
.filter(e -> e.getParameters().isEmpty())
.collect(toSet());
@@ -273,14 +265,15 @@
AutoOneOfTemplateVars vars,
ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsAndTypes,
ExecutableElement kindGetter) {
- vars.props = propertySet(
- propertyMethodsAndTypes, ImmutableListMultimap.of(), ImmutableListMultimap.of());
+ vars.props =
+ propertySet(
+ propertyMethodsAndTypes, ImmutableListMultimap.of(), ImmutableListMultimap.of());
vars.kindGetter = kindGetter.getSimpleName().toString();
vars.kindType = TypeEncoder.encode(kindGetter.getReturnType());
TypeElement javaIoSerializable = elementUtils().getTypeElement("java.io.Serializable");
vars.serializable =
- javaIoSerializable != null // just in case
- && typeUtils().isAssignable(type.asType(), javaIoSerializable.asType());
+ javaIoSerializable != null // just in case
+ && typeUtils().isAssignable(type.asType(), javaIoSerializable.asType());
}
@Override
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoOneOfTemplateVars.java b/value/src/main/java/com/google/auto/value/processor/AutoOneOfTemplateVars.java
index 1e15771..06b24e2 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoOneOfTemplateVars.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoOneOfTemplateVars.java
@@ -25,7 +25,7 @@
* @author emcmanus@google.com (Éamonn McManus)
*/
@SuppressWarnings("unused") // the fields in this class are only read via reflection
-class AutoOneOfTemplateVars extends AutoValueOrOneOfTemplateVars {
+class AutoOneOfTemplateVars extends AutoValueishTemplateVars {
/**
* The properties defined by the parent class's abstract methods. The elements of this set are in
* the same order as the original abstract method declarations in the AutoOneOf class.
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueBuilderProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoValueBuilderProcessor.java
index 62dfeb3..ac6c8ec 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueBuilderProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueBuilderProcessor.java
@@ -15,7 +15,7 @@
*/
package com.google.auto.value.processor;
-import static com.google.auto.value.processor.AutoValueOrOneOfProcessor.hasAnnotationMirror;
+import static com.google.auto.value.processor.AutoValueishProcessor.hasAnnotationMirror;
import static com.google.auto.value.processor.ClassNames.AUTO_VALUE_BUILDER_NAME;
import static com.google.auto.value.processor.ClassNames.AUTO_VALUE_NAME;
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueOrBuilderTemplateVars.java b/value/src/main/java/com/google/auto/value/processor/AutoValueOrBuilderTemplateVars.java
new file mode 100644
index 0000000..86cf497
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueOrBuilderTemplateVars.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2012 Google LLC
+ *
+ * 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.processor;
+
+import com.google.auto.value.processor.AutoValueishProcessor.Property;
+import com.google.auto.value.processor.PropertyBuilderClassifier.PropertyBuilder;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+import java.util.Optional;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.util.Types;
+
+/**
+ * Variables to substitute into the autovalue.vm or builder.vm template.
+ *
+ * @author emcmanus@google.com (Éamonn McManus)
+ */
+@SuppressWarnings("unused") // the fields in this class are only read via reflection
+abstract class AutoValueOrBuilderTemplateVars extends AutoValueishTemplateVars {
+ /**
+ * The properties defined by the parent class's abstract methods. The elements of this set are in
+ * the same order as the original abstract method declarations in the AutoValue class.
+ */
+ ImmutableSet<Property> props;
+
+ /**
+ * The simple name of the generated builder, or empty if there is no builder. This is just
+ * {@code Builder} for AutoValue, since it is nested inside the {@code AutoValue_Foo} class. But
+ * it is {@code AutoBuilder_Foo} for AutoBuilder.
+ */
+ String builderName = "";
+
+ /**
+ * The name of the builder type as it should appear in source code, or empty if there is no
+ * builder type. If class {@code Address} contains {@code @AutoValue.Builder} class Builder then
+ * this will typically be {@code "Address.Builder"}.
+ */
+ String builderTypeName = "";
+
+ /**
+ * The formal generic signature of the {@code AutoValue.Builder} class. This is empty, or contains
+ * type variables with optional bounds, for example {@code <K, V extends K>}.
+ */
+ String builderFormalTypes = "";
+
+ /**
+ * The generic signature used by the generated builder subclass for its superclass reference. This
+ * is empty, or contains only type variables with no bounds, for example {@code <K, V>}.
+ */
+ String builderActualTypes = "";
+
+ /** True if the builder being implemented is an interface, false if it is an abstract class. */
+ Boolean builderIsInterface = false;
+
+ /**
+ * The full spelling of any annotations to add to the generated builder subclass, or an empty list
+ * if there are none. A non-empty value might look something like {@code
+ * @`java.lang.SuppressWarnings`("Immutable")}. The {@code ``} marks are explained in
+ * {@link TypeEncoder}.
+ */
+ ImmutableList<String> builderAnnotations = ImmutableList.of();
+
+ /** The builder's build method, often {@code "build"}. */
+ Optional<SimpleMethod> buildMethod = Optional.empty();
+
+ /** The type that will be built by the {@code build()} method of a builder. */
+ String builtType;
+
+ /**
+ * The constructor or method invocation that the {@code build()} method of a builder should use,
+ * without any parameters. This might be {@code "new Foo"} or {@code "Foo.someMethod"}.
+ */
+ String build;
+
+ /**
+ * A multimap from property names (like foo) to the corresponding setters. The same property may
+ * be set by more than one setter. For example, an ImmutableList might be set by {@code
+ * setFoo(ImmutableList<String>)} and {@code setFoo(String[])}.
+ */
+ ImmutableMultimap<String, BuilderSpec.PropertySetter> builderSetters = ImmutableMultimap.of();
+
+ /**
+ * A map from property names to information about the associated property builder. A property
+ * called foo (defined by a method foo() or getFoo()) can have a property builder called
+ * fooBuilder(). The type of foo must be a type that has an associated builder following certain
+ * conventions. Guava immutable types such as ImmutableList follow those conventions, as do many
+ * {@code @AutoValue} types.
+ */
+ ImmutableMap<String, PropertyBuilder> builderPropertyBuilders = ImmutableMap.of();
+
+ /**
+ * Properties that are required to be set. A property must be set explicitly except in the
+ * following cases:
+ *
+ * <ul>
+ * <li>it is {@code @Nullable} (in which case it defaults to null);
+ * <li>it is {@code Optional} (in which case it defaults to empty);
+ * <li>it has a property-builder method (in which case it defaults to empty).
+ * </ul>
+ */
+ ImmutableSet<Property> builderRequiredProperties = ImmutableSet.of();
+
+ /**
+ * A map from property names to information about the associated property getter. A property
+ * called foo (defined by a method foo() or getFoo()) can have a property getter method with the
+ * same name (foo() or getFoo()) and either the same return type or an Optional (or OptionalInt,
+ * etc) wrapping it.
+ */
+ ImmutableMap<String, BuilderSpec.PropertyGetter> builderGetters = ImmutableMap.of();
+
+ /**
+ * True if the generated builder should have a second constructor with a parameter of the built
+ * class. The constructor produces a new builder that starts off with the values from the
+ * parameter.
+ */
+ Boolean toBuilderConstructor;
+
+ /**
+ * Any {@code toBuilder()} methods, that is methods that return the builder type. AutoBuilder does
+ * not currently support this, but it's included in these shared variables to simplify the
+ * template.
+ */
+ ImmutableList<SimpleMethod> toBuilderMethods;
+
+ /**
+ * Whether to include identifiers in strings in the generated code. If false, exception messages
+ * will not mention properties by name, and {@code toString()} will include neither property names
+ * nor the name of the {@code @AutoValue} class.
+ */
+ Boolean identifiers;
+
+ /**
+ * True if the generated class should be final (there are no extensions that will generate
+ * subclasses)
+ */
+ Boolean isFinal = false;
+
+ /** The type utilities returned by {@link ProcessingEnvironment#getTypeUtils()}. */
+ Types types;
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java
index aafffd7..ab7da92 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueProcessor.java
@@ -16,11 +16,12 @@
package com.google.auto.value.processor;
import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.auto.common.MoreStreams.toImmutableList;
import static com.google.auto.value.processor.ClassNames.AUTO_VALUE_NAME;
import static com.google.common.collect.Sets.difference;
import static com.google.common.collect.Sets.intersection;
+import static java.util.Comparator.naturalOrder;
import static java.util.stream.Collectors.joining;
-import static java.util.stream.Collectors.toList;
import com.google.auto.service.AutoService;
import com.google.auto.value.extension.AutoValueExtension;
@@ -32,11 +33,9 @@
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
@@ -64,8 +63,8 @@
@AutoService(Processor.class)
@SupportedAnnotationTypes(AUTO_VALUE_NAME)
@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.DYNAMIC)
-public class AutoValueProcessor extends AutoValueOrOneOfProcessor {
- private static final String OMIT_IDENTIFIERS_OPTION = "com.google.auto.value.OmitIdentifiers";
+public class AutoValueProcessor extends AutoValueishProcessor {
+ static final String OMIT_IDENTIFIERS_OPTION = "com.google.auto.value.OmitIdentifiers";
// We moved MemoizeExtension to a different package, which had an unexpected effect:
// now if an old version of AutoValue is in the class path, ServiceLoader can pick up both the
@@ -100,10 +99,9 @@
@VisibleForTesting
static ImmutableList<AutoValueExtension> extensionsFromLoader(ClassLoader loader) {
- return ImmutableList.copyOf(
- Iterables.filter(
- SimpleServiceLoader.load(AutoValueExtension.class, loader),
- ext -> !ext.getClass().getName().equals(OLD_MEMOIZE_EXTENSION)));
+ return SimpleServiceLoader.load(AutoValueExtension.class, loader).stream()
+ .filter(ext -> !ext.getClass().getName().equals(OLD_MEMOIZE_EXTENSION))
+ .collect(toImmutableList());
}
@Override
@@ -131,14 +129,17 @@
}
@Override
- public Set<String> getSupportedOptions() {
+ public ImmutableSet<String> getSupportedOptions() {
ImmutableSet.Builder<String> builder = ImmutableSet.builder();
AutoValueExtension.IncrementalExtensionType incrementalType =
extensions.stream()
.map(e -> e.incrementalType(processingEnv))
- .min(Comparator.naturalOrder())
+ .min(naturalOrder())
.orElse(AutoValueExtension.IncrementalExtensionType.ISOLATING);
- builder.add(OMIT_IDENTIFIERS_OPTION).addAll(optionsFor(incrementalType));
+ builder
+ .add(OMIT_IDENTIFIERS_OPTION)
+ .add(Nullables.NULLABLE_OPTION)
+ .addAll(optionsFor(incrementalType));
for (AutoValueExtension extension : extensions) {
builder.addAll(extension.getSupportedOptions());
}
@@ -164,15 +165,6 @@
@Override
void processType(TypeElement type) {
- if (!hasAnnotationMirror(type, AUTO_VALUE_NAME)) {
- // This shouldn't happen unless the compilation environment is buggy,
- // but it has happened in the past and can crash the compiler.
- errorReporter()
- .abortWithError(
- type,
- "[AutoValueCompilerBug] annotation processor for @AutoValue was invoked with a type"
- + " that does not have that annotation; this is probably a compiler bug");
- }
if (type.getKind() != ElementKind.CLASS) {
errorReporter()
.abortWithError(type, "[AutoValueNotClass] @AutoValue only applies to classes");
@@ -216,7 +208,7 @@
Optional<BuilderSpec.Builder> builder = builderSpec.getBuilder();
ImmutableSet<ExecutableElement> toBuilderMethods;
if (builder.isPresent()) {
- toBuilderMethods = builder.get().toBuilderMethods(typeUtils(), abstractMethods);
+ toBuilderMethods = builder.get().toBuilderMethods(typeUtils(), type, abstractMethods);
} else {
toBuilderMethods = ImmutableSet.of();
}
@@ -226,8 +218,9 @@
ImmutableMap<String, ExecutableElement> properties =
propertyNameToMethodMap(propertyMethodsAndTypes.keySet());
- ExtensionContext context = new ExtensionContext(
- processingEnv, type, properties, propertyMethodsAndTypes, abstractMethods);
+ ExtensionContext context =
+ new ExtensionContext(
+ processingEnv, type, properties, propertyMethodsAndTypes, abstractMethods);
ImmutableList<AutoValueExtension> applicableExtensions = applicableExtensions(type, context);
ImmutableSet<ExecutableElement> consumedMethods =
methodsConsumedByExtensions(
@@ -240,21 +233,23 @@
propertyMethodsAndTypes =
propertyMethodsIn(immutableSetDifference(abstractMethods, toBuilderMethods), type);
properties = propertyNameToMethodMap(propertyMethodsAndTypes.keySet());
- context = new ExtensionContext(
- processingEnv, type, properties, propertyMethodsAndTypes, allAbstractMethods);
+ context =
+ new ExtensionContext(
+ processingEnv, type, properties, propertyMethodsAndTypes, allAbstractMethods);
}
ImmutableSet<ExecutableElement> propertyMethods = propertyMethodsAndTypes.keySet();
boolean extensionsPresent = !applicableExtensions.isEmpty();
validateMethods(type, abstractMethods, toBuilderMethods, propertyMethods, extensionsPresent);
- String finalSubclass = generatedSubclassName(type, 0);
+ String finalSubclass = TypeSimplifier.simpleNameOf(generatedSubclassName(type, 0));
AutoValueTemplateVars vars = new AutoValueTemplateVars();
- vars.finalSubclass = TypeSimplifier.simpleNameOf(finalSubclass);
vars.types = processingEnv.getTypeUtils();
vars.identifiers = !processingEnv.getOptions().containsKey(OMIT_IDENTIFIERS_OPTION);
defineSharedVarsForType(type, methods, vars);
defineVarsForType(type, vars, toBuilderMethods, propertyMethodsAndTypes, builder);
+ vars.builtType = vars.origClass + vars.actualTypes;
+ vars.build = "new " + finalSubclass + vars.actualTypes;
// If we've encountered problems then we might end up invoking extensions with inconsistent
// state. Anyway we probably don't want to generate code which is likely to provoke further
@@ -276,7 +271,7 @@
text = Reformatter.fixup(text);
writeSourceFile(subclass, text, type);
GwtSerialization gwtSerialization = new GwtSerialization(gwtCompatibility, processingEnv, type);
- gwtSerialization.maybeWriteGwtSerializer(vars);
+ gwtSerialization.maybeWriteGwtSerializer(vars, finalSubclass);
}
// Invokes each of the given extensions to generate its subclass, and returns the number of
@@ -431,22 +426,22 @@
ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsAndTypes,
Optional<BuilderSpec.Builder> maybeBuilder) {
ImmutableSet<ExecutableElement> propertyMethods = propertyMethodsAndTypes.keySet();
- // We can't use ImmutableList.toImmutableList() for obscure Google-internal reasons.
vars.toBuilderMethods =
- ImmutableList.copyOf(toBuilderMethods.stream().map(SimpleMethod::new).collect(toList()));
+ toBuilderMethods.stream().map(SimpleMethod::new).collect(toImmutableList());
+ vars.toBuilderConstructor = !vars.toBuilderMethods.isEmpty();
ImmutableListMultimap<ExecutableElement, AnnotationMirror> annotatedPropertyFields =
propertyFieldAnnotationMap(type, propertyMethods);
ImmutableListMultimap<ExecutableElement, AnnotationMirror> annotatedPropertyMethods =
propertyMethodAnnotationMap(type, propertyMethods);
vars.props =
propertySet(propertyMethodsAndTypes, annotatedPropertyFields, annotatedPropertyMethods);
- vars.serialVersionUID = getSerialVersionUID(type);
// Check for @AutoValue.Builder and add appropriate variables if it is present.
maybeBuilder.ifPresent(
builder -> {
ImmutableBiMap<ExecutableElement, String> methodToPropertyName =
propertyNameToMethodMap(propertyMethods).inverse();
- builder.defineVars(vars, methodToPropertyName);
+ builder.defineVarsForAutoValue(vars, methodToPropertyName);
+ vars.builderName = "Builder";
vars.builderAnnotations = copiedClassAnnotations(builder.builderType());
});
}
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueTemplateVars.java b/value/src/main/java/com/google/auto/value/processor/AutoValueTemplateVars.java
index 8f855bd..e53b92e 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueTemplateVars.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueTemplateVars.java
@@ -15,15 +15,7 @@
*/
package com.google.auto.value.processor;
-import com.google.auto.value.processor.PropertyBuilderClassifier.PropertyBuilder;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.ImmutableSet;
import com.google.escapevelocity.Template;
-import java.util.Optional;
-import javax.annotation.processing.ProcessingEnvironment;
-import javax.lang.model.util.Types;
/**
* The variables to substitute into the autovalue.vm template.
@@ -31,22 +23,7 @@
* @author emcmanus@google.com (Éamonn McManus)
*/
@SuppressWarnings("unused") // the fields in this class are only read via reflection
-class AutoValueTemplateVars extends AutoValueOrOneOfTemplateVars {
- /**
- * The properties defined by the parent class's abstract methods. The elements of this set are in
- * the same order as the original abstract method declarations in the AutoValue class.
- */
- ImmutableSet<AutoValueOrOneOfProcessor.Property> props;
-
- /**
- * Whether to include identifiers in strings in the generated code. If false, exception messages
- * will not mention properties by name, and {@code toString()} will include neither property names
- * nor the name of the {@code @AutoValue} class.
- */
- Boolean identifiers;
-
- /** The type utilities returned by {@link ProcessingEnvironment#getTypeUtils()}. */
- Types types;
+class AutoValueTemplateVars extends AutoValueOrBuilderTemplateVars {
/**
* The encoding of the {@code @GwtCompatible} annotation to add to this class, or an empty string
@@ -56,100 +33,14 @@
*/
String gwtCompatibleAnnotation;
- /** The text of the serialVersionUID constant, or empty if there is none. */
- String serialVersionUID;
-
/** The simple name of the generated subclass. */
String subclass;
/**
- * The simple name of the final generated subclass. For {@code @AutoValue public static class Foo
- * {}} this should always be "AutoValue_Foo".
- */
- String finalSubclass;
-
- /**
- * True if the generated class should be final (there are no extensions that will generate
- * subclasses)
- */
- Boolean isFinal = false;
-
- /**
* The modifiers (for example {@code final} or {@code abstract}) for the generated subclass,
* followed by a space if they are not empty.
*/
String modifiers;
- /**
- * The name of the builder type as it should appear in source code, or empty if there is no
- * builder type. If class {@code Address} contains {@code @AutoValue.Builder} class Builder then
- * this will typically be {@code "Address.Builder"}.
- */
- String builderTypeName = "";
-
- /**
- * The formal generic signature of the {@code AutoValue.Builder} class. This is empty, or contains
- * type variables with optional bounds, for example {@code <K, V extends K>}.
- */
- String builderFormalTypes = "";
- /**
- * The generic signature used by the generated builder subclass for its superclass reference. This
- * is empty, or contains only type variables with no bounds, for example {@code <K, V>}.
- */
- String builderActualTypes = "";
-
- /** True if the builder being implemented is an interface, false if it is an abstract class. */
- Boolean builderIsInterface = false;
-
- /**
- * The full spelling of any annotations to add to the generated builder subclass, or an empty list
- * if there are none. A non-empty value might look something like {@code
- * @`java.lang.SuppressWarnings`("Immutable")}. The {@code ``} marks are explained in
- * {@link TypeEncoder}.
- */
- ImmutableList<String> builderAnnotations = ImmutableList.of();
-
- /** The builder's build method, often {@code "build"}. */
- Optional<SimpleMethod> buildMethod = Optional.empty();
-
- /**
- * A multimap from property names (like foo) to the corresponding setters. The same property may
- * be set by more than one setter. For example, an ImmutableList might be set by {@code
- * setFoo(ImmutableList<String>)} and {@code setFoo(String[])}.
- */
- ImmutableMultimap<String, BuilderSpec.PropertySetter> builderSetters = ImmutableMultimap.of();
-
- /**
- * A map from property names to information about the associated property builder. A property
- * called foo (defined by a method foo() or getFoo()) can have a property builder called
- * fooBuilder(). The type of foo must be a type that has an associated builder following certain
- * conventions. Guava immutable types such as ImmutableList follow those conventions, as do many
- * {@code @AutoValue} types.
- */
- ImmutableMap<String, PropertyBuilder> builderPropertyBuilders = ImmutableMap.of();
-
- /**
- * Properties that are required to be set. A property must be set explicitly except in the
- * following cases:
- *
- * <ul>
- * <li>it is {@code @Nullable} (in which case it defaults to null);
- * <li>it is {@code Optional} (in which case it defaults to empty);
- * <li>it has a property-builder method (in which case it defaults to empty).
- * </ul>
- */
- ImmutableSet<AutoValueProcessor.Property> builderRequiredProperties = ImmutableSet.of();
-
- /**
- * A map from property names to information about the associated property getter. A property
- * called foo (defined by a method foo() or getFoo()) can have a property getter method with the
- * same name (foo() or getFoo()) and either the same return type or an Optional (or OptionalInt,
- * etc) wrapping it.
- */
- ImmutableMap<String, BuilderSpec.PropertyGetter> builderGetters = ImmutableMap.of();
-
- /** Any {@code toBuilder()} methods, that is methods that return the builder type. */
- ImmutableList<SimpleMethod> toBuilderMethods;
-
private static final Template TEMPLATE = parsedTemplateForResource("autovalue.vm");
@Override
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfProcessor.java b/value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java
similarity index 87%
rename from value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfProcessor.java
rename to value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java
index 36a82bd..93f2f79 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfProcessor.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueishProcessor.java
@@ -19,6 +19,8 @@
import static com.google.auto.common.GeneratedAnnotations.generatedAnnotation;
import static com.google.auto.common.MoreElements.getPackage;
import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreStreams.toImmutableList;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
import static com.google.auto.value.processor.ClassNames.AUTO_VALUE_PACKAGE_NAME;
import static com.google.auto.value.processor.ClassNames.COPY_ANNOTATIONS_NAME;
import static com.google.common.collect.Iterables.getOnlyElement;
@@ -56,6 +58,7 @@
import java.util.OptionalInt;
import java.util.Set;
import java.util.function.Predicate;
+import java.util.stream.IntStream;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
@@ -82,11 +85,12 @@
import javax.tools.JavaFileObject;
/**
- * Shared code between AutoValueProcessor and AutoOneOfProcessor.
+ * Shared code between {@link AutoValueProcessor}, {@link AutoOneOfProcessor}, and {@link
+ * AutoBuilderProcessor}.
*
* @author emcmanus@google.com (Éamonn McManus)
*/
-abstract class AutoValueOrOneOfProcessor extends AbstractProcessor {
+abstract class AutoValueishProcessor extends AbstractProcessor {
private final String annotationClassName;
/**
@@ -96,7 +100,7 @@
*/
private final List<String> deferredTypeNames = new ArrayList<>();
- AutoValueOrOneOfProcessor(String annotationClassName) {
+ AutoValueishProcessor(String annotationClassName) {
this.annotationClassName = annotationClassName;
}
@@ -106,11 +110,13 @@
private String simpleAnnotationName;
private ErrorReporter errorReporter;
+ private Nullables nullables;
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
errorReporter = new ErrorReporter(processingEnv);
+ nullables = new Nullables(processingEnv);
}
final ErrorReporter errorReporter() {
@@ -149,30 +155,26 @@
public static class Property {
private final String name;
private final String identifier;
- private final ExecutableElement method;
private final String type;
- private final ImmutableList<String> fieldAnnotations;
- private final ImmutableList<String> methodAnnotations;
+ private final TypeMirror typeMirror;
private final Optional<String> nullableAnnotation;
private final Optionalish optional;
+ private final String getter;
Property(
String name,
String identifier,
- ExecutableElement method,
String type,
- ImmutableList<String> fieldAnnotations,
- ImmutableList<String> methodAnnotations,
- Optional<String> nullableAnnotation) {
+ TypeMirror typeMirror,
+ Optional<String> nullableAnnotation,
+ String getter) {
this.name = name;
this.identifier = identifier;
- this.method = method;
this.type = type;
- this.fieldAnnotations = fieldAnnotations;
- this.methodAnnotations = methodAnnotations;
+ this.typeMirror = typeMirror;
this.nullableAnnotation = nullableAnnotation;
- TypeMirror propertyType = method.getReturnType();
- this.optional = Optionalish.createIfOptional(propertyType);
+ this.optional = Optionalish.createIfOptional(typeMirror);
+ this.getter = getter;
}
/**
@@ -196,16 +198,8 @@
return name;
}
- /**
- * Returns the name of the getter method for this property as defined by the {@code @AutoValue}
- * class. For property {@code foo}, this will be {@code foo} or {@code getFoo} or {@code isFoo}.
- */
- public String getGetter() {
- return method.getSimpleName().toString();
- }
-
public TypeMirror getTypeMirror() {
- return method.getReturnType();
+ return typeMirror;
}
public String getType() {
@@ -213,23 +207,7 @@
}
public TypeKind getKind() {
- return method.getReturnType().getKind();
- }
-
- /**
- * Returns the annotations (in string form) that should be applied to the property's field
- * declaration.
- */
- public List<String> getFieldAnnotations() {
- return fieldAnnotations;
- }
-
- /**
- * Returns the annotations (in string form) that should be applied to the property's method
- * implementation.
- */
- public List<String> getMethodAnnotations() {
- return methodAnnotations;
+ return typeMirror.getKind();
}
/**
@@ -257,13 +235,66 @@
return nullableAnnotation.isPresent();
}
+ /**
+ * Returns the name of the getter method for this property as defined by the {@code @AutoValue}
+ * or {@code @AutoBuilder} class. For property {@code foo}, this will be {@code foo} or {@code
+ * getFoo} or {@code isFoo}. For AutoValue, this will also be the name of a getter method in a
+ * builder; in the case of AutoBuilder it will only be that and may be null.
+ */
+ public String getGetter() {
+ return getter;
+ }
+ }
+
+ /** A {@link Property} that corresponds to an abstract getter method in the source. */
+ public static class GetterProperty extends Property {
+ private final ExecutableElement method;
+ private final ImmutableList<String> fieldAnnotations;
+ private final ImmutableList<String> methodAnnotations;
+
+ GetterProperty(
+ String name,
+ String identifier,
+ ExecutableElement method,
+ String type,
+ ImmutableList<String> fieldAnnotations,
+ ImmutableList<String> methodAnnotations,
+ Optional<String> nullableAnnotation) {
+ super(
+ name,
+ identifier,
+ type,
+ method.getReturnType(),
+ nullableAnnotation,
+ method.getSimpleName().toString());
+ this.method = method;
+ this.fieldAnnotations = fieldAnnotations;
+ this.methodAnnotations = methodAnnotations;
+ }
+
+ /**
+ * Returns the annotations (in string form) that should be applied to the property's field
+ * declaration.
+ */
+ public List<String> getFieldAnnotations() {
+ return fieldAnnotations;
+ }
+
+ /**
+ * Returns the annotations (in string form) that should be applied to the property's method
+ * implementation.
+ */
+ public List<String> getMethodAnnotations() {
+ return methodAnnotations;
+ }
+
public String getAccess() {
return SimpleMethod.access(method);
}
@Override
public boolean equals(Object obj) {
- return obj instanceof Property && ((Property) obj).method.equals(method);
+ return obj instanceof GetterProperty && ((GetterProperty) obj).method.equals(method);
}
@Override
@@ -289,8 +320,7 @@
}
simpleAnnotationName = annotationType.getSimpleName().toString();
List<TypeElement> deferredTypes =
- deferredTypeNames
- .stream()
+ deferredTypeNames.stream()
.map(name -> elementUtils().getTypeElement(name))
.collect(toList());
if (roundEnv.processingOver()) {
@@ -383,7 +413,7 @@
(propertyMethod, returnType) -> {
String propertyType =
TypeEncoder.encodeWithAnnotations(
- returnType, getExcludedAnnotationTypes(propertyMethod));
+ returnType, ImmutableList.of(), getExcludedAnnotationTypes(propertyMethod));
String propertyName = methodToPropertyName.get(propertyMethod);
String identifier = methodToIdentifier.get(propertyMethod);
ImmutableList<String> fieldAnnotations =
@@ -393,7 +423,7 @@
ImmutableList<String> methodAnnotations = annotationStrings(methodAnnotationMirrors);
Optional<String> nullableAnnotation = nullableAnnotationForMethod(propertyMethod);
Property p =
- new Property(
+ new GetterProperty(
propertyName,
identifier,
propertyMethod,
@@ -411,11 +441,9 @@
return props.build();
}
- /** Defines the template variables that are shared by AutoValue and AutoOneOf. */
+ /** Defines the template variables that are shared by AutoValue, AutoOneOf, and AutoBuilder. */
final void defineSharedVarsForType(
- TypeElement type,
- ImmutableSet<ExecutableElement> methods,
- AutoValueOrOneOfTemplateVars vars) {
+ TypeElement type, ImmutableSet<ExecutableElement> methods, AutoValueishTemplateVars vars) {
vars.pkg = TypeSimplifier.packageNameOf(type);
vars.origClass = TypeSimplifier.classNameOf(type);
vars.simpleClassName = TypeSimplifier.simpleNameOf(vars.origClass);
@@ -423,7 +451,7 @@
generatedAnnotation(elementUtils(), processingEnv.getSourceVersion())
.map(annotation -> TypeEncoder.encode(annotation.asType()))
.orElse("");
- vars.formalTypes = TypeEncoder.formalTypeParametersString(type);
+ vars.formalTypes = TypeEncoder.typeParametersString(type.getTypeParameters());
vars.actualTypes = TypeSimplifier.actualTypeParametersString(type);
vars.wildcardTypes = wildcardTypeParametersString(type);
vars.annotations = copiedClassAnnotations(type);
@@ -432,14 +460,17 @@
vars.toString = methodsToGenerate.containsKey(ObjectMethod.TO_STRING);
vars.equals = methodsToGenerate.containsKey(ObjectMethod.EQUALS);
vars.hashCode = methodsToGenerate.containsKey(ObjectMethod.HASH_CODE);
- vars.equalsParameterType = equalsParameterType(methodsToGenerate);
+ Optional<AnnotationMirror> nullable = nullables.appropriateNullableGivenMethods(methods);
+ vars.equalsParameterType = equalsParameterType(methodsToGenerate, nullable);
+ vars.serialVersionUID = getSerialVersionUID(type);
}
/** Returns the spelling to be used in the generated code for the given list of annotations. */
static ImmutableList<String> annotationStrings(List<? extends AnnotationMirror> annotations) {
// TODO(b/68008628): use ImmutableList.toImmutableList() when that works.
- return ImmutableList.copyOf(
- annotations.stream().map(AnnotationOutput::sourceFormForAnnotation).collect(toList()));
+ return annotations.stream()
+ .map(AnnotationOutput::sourceFormForAnnotation)
+ .collect(toImmutableList());
}
/**
@@ -454,7 +485,7 @@
static String generatedClassName(TypeElement type, String prefix) {
String name = type.getSimpleName().toString();
while (type.getEnclosingElement() instanceof TypeElement) {
- type = (TypeElement) type.getEnclosingElement();
+ type = MoreElements.asType(type.getEnclosingElement());
name = type.getSimpleName() + "_" + name;
}
String pkg = TypeSimplifier.packageNameOf(type);
@@ -566,12 +597,9 @@
}
private static OptionalInt nullableAnnotationIndex(List<? extends AnnotationMirror> annotations) {
- for (int i = 0; i < annotations.size(); i++) {
- if (isNullable(annotations.get(i))) {
- return OptionalInt.of(i);
- }
- }
- return OptionalInt.empty();
+ return IntStream.range(0, annotations.size())
+ .filter(i -> isNullable(annotations.get(i)))
+ .findFirst();
}
private static boolean isNullable(AnnotationMirror annotation) {
@@ -583,21 +611,19 @@
* includes {@code isFoo} methods if they return {@code boolean}. This corresponds to JavaBeans
* conventions.
*/
- static ImmutableSet<ExecutableElement> prefixedGettersIn(Iterable<ExecutableElement> methods) {
- ImmutableSet.Builder<ExecutableElement> getters = ImmutableSet.builder();
- for (ExecutableElement method : methods) {
- String name = method.getSimpleName().toString();
- // Note that getfoo() (without a capital) is still a getter.
- boolean get = name.startsWith("get") && !name.equals("get");
- boolean is =
- name.startsWith("is")
- && !name.equals("is")
- && method.getReturnType().getKind() == TypeKind.BOOLEAN;
- if (get || is) {
- getters.add(method);
- }
- }
- return getters.build();
+ static ImmutableSet<ExecutableElement> prefixedGettersIn(Collection<ExecutableElement> methods) {
+ return methods.stream()
+ .filter(AutoValueishProcessor::isPrefixedGetter)
+ .collect(toImmutableSet());
+ }
+
+ static boolean isPrefixedGetter(ExecutableElement method) {
+ String name = method.getSimpleName().toString();
+ // Note that getfoo() (without a capital) is still a getter.
+ return (name.startsWith("get") && !name.equals("get"))
+ || (name.startsWith("is")
+ && !name.equals("is")
+ && method.getReturnType().getKind() == TypeKind.BOOLEAN);
}
/**
@@ -611,7 +637,7 @@
* anyway, so the special behaviour is not useful, and of course it behaves poorly with examples
* like {@code OAuth}.
*/
- private static String nameWithoutPrefix(String name) {
+ static String nameWithoutPrefix(String name) {
if (name.startsWith("get")) {
name = name.substring(3);
} else {
@@ -622,27 +648,33 @@
}
/**
- * Checks that, if the given {@code @AutoValue} or {@code @AutoOneOf} class is nested, it is
- * static and not private. This check is not necessary for correctness, since the generated code
- * would not compile if the check fails, but it produces better error messages for the user.
+ * Checks that, if the given {@code @AutoValue}, {@code @AutoOneOf}, or {@code @AutoBuilder} class
+ * is nested, it is static and not private. This check is not necessary for correctness, since the
+ * generated code would not compile if the check fails, but it produces better error messages for
+ * the user.
*/
final void checkModifiersIfNested(TypeElement type) {
+ checkModifiersIfNested(type, type, simpleAnnotationName);
+ }
+
+ final void checkModifiersIfNested(TypeElement type, TypeElement reportedType, String what) {
ElementKind enclosingKind = type.getEnclosingElement().getKind();
if (enclosingKind.isClass() || enclosingKind.isInterface()) {
if (type.getModifiers().contains(Modifier.PRIVATE)) {
errorReporter.abortWithError(
- type, "[AutoValuePrivate] @%s class must not be private", simpleAnnotationName);
+ reportedType, "[%sPrivate] @%s class must not be private", simpleAnnotationName, what);
} else if (Visibility.effectiveVisibilityOfElement(type).equals(Visibility.PRIVATE)) {
// The previous case, where the class itself is private, is much commoner so it deserves
// its own error message, even though it would be caught by the test here too.
errorReporter.abortWithError(
- type,
- "[AutoValueInPrivate] @%s class must not be nested in a private class",
- simpleAnnotationName);
+ reportedType,
+ "[%sInPrivate] @%s class must not be nested in a private class",
+ simpleAnnotationName,
+ what);
}
if (!type.getModifiers().contains(Modifier.STATIC)) {
errorReporter.abortWithError(
- type, "[AutoValueInner] Nested @%s class must be static", simpleAnnotationName);
+ reportedType, "[%sInner] Nested @%s class must be static", simpleAnnotationName, what);
}
}
// In principle type.getEnclosingElement() could be an ExecutableElement (for a class
@@ -693,7 +725,7 @@
ObjectMethod override = objectMethodToOverride(method);
boolean canGenerate =
method.getModifiers().contains(Modifier.ABSTRACT)
- || isJavaLangObject((TypeElement) method.getEnclosingElement());
+ || isJavaLangObject(MoreElements.asType(method.getEnclosingElement()));
if (!override.equals(ObjectMethod.NONE) && canGenerate) {
methodsToGenerate.put(override, method);
}
@@ -705,14 +737,25 @@
* Returns the encoded parameter type of the {@code equals(Object)} method that is to be
* generated, or an empty string if the method is not being generated. The parameter type includes
* any type annotations, for example {@code @Nullable}.
+ *
+ * @param methodsToGenerate the Object methods that are being generated
+ * @param nullable the type of a {@code @Nullable} type annotation that we have found, if any
*/
- static String equalsParameterType(Map<ObjectMethod, ExecutableElement> methodsToGenerate) {
+ static String equalsParameterType(
+ Map<ObjectMethod, ExecutableElement> methodsToGenerate, Optional<AnnotationMirror> nullable) {
ExecutableElement equals = methodsToGenerate.get(ObjectMethod.EQUALS);
if (equals == null) {
return ""; // this will not be referenced because no equals method will be generated
}
TypeMirror parameterType = equals.getParameters().get(0).asType();
- return TypeEncoder.encodeWithAnnotations(parameterType);
+ // Add @Nullable if we know one and the parameter doesn't already have one.
+ // The @Nullable we add will be a type annotation, but if the parameter already has @Nullable
+ // then that might be a type annotation or an annotation on the parameter.
+ ImmutableList<AnnotationMirror> extraAnnotations =
+ nullable.isPresent() && !nullableAnnotationFor(equals, parameterType).isPresent()
+ ? ImmutableList.of(nullable.get())
+ : ImmutableList.of();
+ return TypeEncoder.encodeWithAnnotations(parameterType, extraAnnotations, ImmutableSet.of());
}
/**
@@ -751,8 +794,7 @@
* {@code toString()}.
*/
ImmutableMap<ExecutableElement, TypeMirror> propertyMethodsIn(
- Set<ExecutableElement> abstractMethods,
- TypeElement autoValueOrOneOfType) {
+ Set<ExecutableElement> abstractMethods, TypeElement autoValueOrOneOfType) {
DeclaredType declaredType = MoreTypes.asDeclared(autoValueOrOneOfType.asType());
ImmutableSet.Builder<ExecutableElement> properties = ImmutableSet.builder();
for (ExecutableElement method : abstractMethods) {
@@ -778,7 +820,7 @@
TypeMirror type = getter.getReturnType();
if (type.getKind() == TypeKind.ARRAY) {
TypeMirror componentType = MoreTypes.asArray(type).getComponentType();
- if (componentType.getKind().isPrimitive()) {
+ if (componentType.getKind().isPrimitive()) {
warnAboutPrimitiveArrays(autoValueClass, getter);
} else {
errorReporter.reportError(
@@ -829,12 +871,13 @@
@Override
public Boolean visitArray(List<? extends AnnotationValue> list, Void p) {
return list.stream().map(AnnotationValue::getValue).anyMatch("mutable"::equals);
- }
+ }
}
/**
- * Returns a string like {@code "1234L"} if {@code type instanceof Serializable} and defines
- * {@code serialVersionUID = 1234L}; otherwise {@code ""}.
+ * Returns a string like {@code "private static final long serialVersionUID = 1234L"} if {@code
+ * type instanceof Serializable} and defines {@code serialVersionUID = 1234L}; otherwise {@code
+ * ""}.
*/
final String getSerialVersionUID(TypeElement type) {
TypeMirror serializable = elementUtils().getTypeElement(Serializable.class.getName()).asType();
@@ -846,7 +889,7 @@
if (field.getModifiers().containsAll(Arrays.asList(Modifier.STATIC, Modifier.FINAL))
&& field.asType().getKind() == TypeKind.LONG
&& value != null) {
- return value + "L";
+ return "private static final long serialVersionUID = " + value + "L;";
} else {
errorReporter.reportError(
field, "serialVersionUID must be a static final long compile-time constant");
@@ -889,7 +932,25 @@
// Only copy annotations from a class if it has @AutoValue.CopyAnnotations.
if (hasAnnotationMirror(type, COPY_ANNOTATIONS_NAME)) {
Set<String> excludedAnnotations =
- union(getExcludedAnnotationClassNames(type), getAnnotationsMarkedWithInherited(type));
+ ImmutableSet.<String>builder()
+ .addAll(getExcludedAnnotationClassNames(type))
+ .addAll(getAnnotationsMarkedWithInherited(type))
+ //
+ // Kotlin classes have an intrinsic @Metadata annotation generated
+ // onto them by kotlinc. This annotation is specific to the annotated
+ // class and should not be implicitly copied. Doing so can mislead
+ // static analysis or metaprogramming tooling that reads the data
+ // contained in these annotations.
+ //
+ // It may be surprising to see AutoValue classes written in Kotlin
+ // when they could be written as Kotlin data classes, but this can
+ // come up in cases where consumers rely on AutoValue features or
+ // extensions that are not available in data classes.
+ //
+ // See: https://github.com/google/auto/issues/1087
+ //
+ .add(ClassNames.KOTLIN_METADATA_NAME)
+ .build();
return copyAnnotations(type, type, excludedAnnotations);
} else {
@@ -919,8 +980,7 @@
@SuppressWarnings("unchecked")
List<AnnotationValue> excludedClasses =
(List<AnnotationValue>) getAnnotationValue(maybeAnnotation.get(), "exclude").getValue();
- return excludedClasses
- .stream()
+ return excludedClasses.stream()
.map(annotationValue -> (DeclaredType) annotationValue.getValue())
.collect(toCollection(TypeMirrorSet::new));
}
@@ -930,17 +990,14 @@
* strings that are fully-qualified class names.
*/
private Set<String> getExcludedAnnotationClassNames(Element element) {
- return getExcludedAnnotationTypes(element)
- .stream()
+ return getExcludedAnnotationTypes(element).stream()
.map(MoreTypes::asTypeElement)
.map(typeElement -> typeElement.getQualifiedName().toString())
.collect(toSet());
}
private static Set<String> getAnnotationsMarkedWithInherited(Element element) {
- return element
- .getAnnotationMirrors()
- .stream()
+ return element.getAnnotationMirrors().stream()
.filter(a -> isAnnotationPresent(a.getAnnotationType().asElement(), Inherited.class))
.map(a -> getAnnotationFqName(a))
.collect(toSet());
@@ -1007,9 +1064,7 @@
Set<String> returnTypeAnnotations =
getReturnTypeAnnotations(method, this::annotationAppliesToFields);
Set<String> nonFieldAnnotations =
- method
- .getAnnotationMirrors()
- .stream()
+ method.getAnnotationMirrors().stream()
.map(a -> a.getAnnotationType().asElement())
.map(MoreElements::asType)
.filter(a -> !annotationAppliesToFields(a))
@@ -1027,10 +1082,7 @@
private Set<String> getReturnTypeAnnotations(
ExecutableElement method, Predicate<TypeElement> typeFilter) {
- return method
- .getReturnType()
- .getAnnotationMirrors()
- .stream()
+ return method.getReturnType().getAnnotationMirrors().stream()
.map(a -> a.getAnnotationType().asElement())
.map(MoreElements::asType)
.filter(typeFilter)
diff --git a/value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfTemplateVars.java b/value/src/main/java/com/google/auto/value/processor/AutoValueishTemplateVars.java
similarity index 87%
rename from value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfTemplateVars.java
rename to value/src/main/java/com/google/auto/value/processor/AutoValueishTemplateVars.java
index 9fdbea4..9ff2891 100644
--- a/value/src/main/java/com/google/auto/value/processor/AutoValueOrOneOfTemplateVars.java
+++ b/value/src/main/java/com/google/auto/value/processor/AutoValueishTemplateVars.java
@@ -18,12 +18,12 @@
import com.google.common.collect.ImmutableList;
/**
- * The variables to substitute into the autovalue.vm or autooneof.vm template.
+ * The variables to substitute into the autovalue.vm, autooneof.vm, or builder.vm templates.
*
* @author emcmanus@google.com (Éamonn McManus)
*/
@SuppressWarnings("unused") // the fields in this class are only read via reflection
-abstract class AutoValueOrOneOfTemplateVars extends TemplateVars {
+abstract class AutoValueishTemplateVars extends TemplateVars {
/** Whether to generate an equals(Object) method. */
Boolean equals;
@@ -81,4 +81,11 @@
* wildcard, for example {@code <?, ?>}.
*/
String wildcardTypes;
+
+ /**
+ * The text of the complete serialVersionUID declaration, or empty if there is none. When
+ * non-empty, it will be something like {@code private static final long serialVersionUID =
+ * 123L;}.
+ */
+ String serialVersionUID;
}
diff --git a/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifier.java b/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifier.java
index 81751e3..51773e6 100644
--- a/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifier.java
+++ b/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifier.java
@@ -15,8 +15,7 @@
*/
package com.google.auto.value.processor;
-import static com.google.auto.value.processor.AutoValueOrOneOfProcessor.nullableAnnotationFor;
-import static com.google.common.collect.Sets.difference;
+import static com.google.auto.value.processor.AutoValueishProcessor.nullableAnnotationFor;
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
@@ -38,7 +37,9 @@
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
+import java.util.stream.Stream;
import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
@@ -54,19 +55,35 @@
/**
* Classifies methods inside builder types, based on their names and parameter and return types.
*
+ * @param <E> the kind of {@link Element} that the corresponding properties are defined by. This is
+ * {@link ExecutableElement} for AutoValue, where properties are defined by abstract methods,
+ * and {@link VariableElement} for AutoBuilder, where they are defined by constructor or method
+ * parameters.
* @author Éamonn McManus
*/
-class BuilderMethodClassifier {
+abstract class BuilderMethodClassifier<E extends Element> {
private static final Equivalence<TypeMirror> TYPE_EQUIVALENCE = MoreTypes.equivalence();
private final ErrorReporter errorReporter;
private final Types typeUtils;
private final Elements elementUtils;
- private final TypeElement autoValueClass;
+ private final TypeMirror builtType;
private final TypeElement builderType;
- private final ImmutableBiMap<ExecutableElement, String> getterToPropertyName;
- private final ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType;
- private final ImmutableMap<String, ExecutableElement> getterNameToGetter;
+
+ /**
+ * Property types, rewritten to refer to type variables in the builder. For example, suppose you
+ * have {@code @AutoValue abstract class Foo<T>} with a getter {@code abstract T bar()} and a
+ * builder {@code @AutoValue.Builder interface Builder<T>} with a setter {@code abstract
+ * Builder<T> setBar(T t)}. Then the {@code T} of {@code Foo<T>} and the {@code T} of {@code
+ * Foo.Builder<T>} are two separate variables. Originally {@code bar()} returned the {@code T} of
+ * {@code Foo<T>}, but in this map we have rewritten it to be the {@code T} of {@code
+ * Foo.Builder<T>}.
+ *
+ * <p>Importantly, this rewrite <b>loses type annotations</b>, so when those are important we must
+ * be careful to look at the original type as reported by the {@link #originalPropertyType}
+ * method.
+ */
+ private final ImmutableMap<String, TypeMirror> rewrittenPropertyTypes;
private final Set<ExecutableElement> buildMethods = new LinkedHashSet<>();
private final Map<String, BuilderSpec.PropertyGetter> builderGetters = new LinkedHashMap<>();
@@ -79,76 +96,27 @@
private boolean settersPrefixed;
- private BuilderMethodClassifier(
+ BuilderMethodClassifier(
ErrorReporter errorReporter,
ProcessingEnvironment processingEnv,
- TypeElement autoValueClass,
+ TypeMirror builtType,
TypeElement builderType,
- ImmutableBiMap<ExecutableElement, String> getterToPropertyName,
- ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType) {
+ ImmutableMap<String, TypeMirror> rewrittenPropertyTypes) {
this.errorReporter = errorReporter;
this.typeUtils = processingEnv.getTypeUtils();
this.elementUtils = processingEnv.getElementUtils();
- this.autoValueClass = autoValueClass;
+ this.builtType = builtType;
this.builderType = builderType;
- this.getterToPropertyName = getterToPropertyName;
- this.getterToPropertyType = getterToPropertyType;
- ImmutableMap.Builder<String, ExecutableElement> getterToPropertyNameBuilder =
- ImmutableMap.builder();
- for (ExecutableElement getter : getterToPropertyName.keySet()) {
- getterToPropertyNameBuilder.put(getter.getSimpleName().toString(), getter);
- }
- this.getterNameToGetter = getterToPropertyNameBuilder.build();
+ this.rewrittenPropertyTypes = rewrittenPropertyTypes;
this.eclipseHack = new EclipseHack(processingEnv);
}
/**
- * Classifies the given methods from a builder type and its ancestors.
- *
- * @param methods the abstract methods in {@code builderType} and its ancestors.
- * @param errorReporter where to report errors.
- * @param processingEnv the ProcessingEnvironment for annotation processing.
- * @param autoValueClass the {@code AutoValue} class containing the builder.
- * @param builderType the builder class or interface within {@code autoValueClass}.
- * @param getterToPropertyName a map from getter methods to the properties they get.
- * @param getterToPropertyType a map from getter methods to their return types. The return types
- * here use type parameters from the builder class (if any) rather than from the {@code
- * AutoValue} class, even though the getter methods are in the latter.
- * @param autoValueHasToBuilder true if the containing {@code @AutoValue} class has a {@code
- * toBuilder()} method.
- * @return an {@code Optional} that contains the results of the classification if it was
- * successful or nothing if it was not.
- */
- static Optional<BuilderMethodClassifier> classify(
- Iterable<ExecutableElement> methods,
- ErrorReporter errorReporter,
- ProcessingEnvironment processingEnv,
- TypeElement autoValueClass,
- TypeElement builderType,
- ImmutableBiMap<ExecutableElement, String> getterToPropertyName,
- ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType,
- boolean autoValueHasToBuilder) {
- BuilderMethodClassifier classifier =
- new BuilderMethodClassifier(
- errorReporter,
- processingEnv,
- autoValueClass,
- builderType,
- getterToPropertyName,
- getterToPropertyType);
- if (classifier.classifyMethods(methods, autoValueHasToBuilder)) {
- return Optional.of(classifier);
- } else {
- return Optional.empty();
- }
- }
-
- /**
* Returns a multimap from the name of a property to the methods that set it. If the property is
* defined by an abstract method in the {@code @AutoValue} class called {@code foo()} or {@code
* getFoo()} then the name of the property is {@code foo} and there will be an entry in the map
- * where the key is {@code "foo"} and the value describes a method in the builder called
- * {@code foo} or {@code setFoo}.
+ * where the key is {@code "foo"} and the value describes a method in the builder called {@code
+ * foo} or {@code setFoo}.
*/
ImmutableMultimap<String, PropertySetter> propertyNameToSetters() {
return ImmutableMultimap.copyOf(
@@ -179,8 +147,7 @@
}
/** Classifies the given methods and sets the state of this object based on what is found. */
- private boolean classifyMethods(
- Iterable<ExecutableElement> methods, boolean autoValueHasToBuilder) {
+ boolean classifyMethods(Iterable<ExecutableElement> methods, boolean autoValueHasToBuilder) {
int startErrorCount = errorReporter.errorCount();
for (ExecutableElement method : methods) {
classifyMethod(method);
@@ -198,49 +165,48 @@
} else {
errorReporter.reportError(
propertyNameToUnprefixedSetters.values().iterator().next().getSetter(),
- "[AutoValueSetNotSet] If any setter methods use the setFoo convention then all must");
+ "[%sSetNotSet] If any setter methods use the setFoo convention then all must",
+ autoWhat());
return false;
}
- getterToPropertyName.forEach(
- (getter, property) -> {
- TypeMirror propertyType = getterToPropertyType.get(getter);
- boolean hasSetter = propertyNameToSetter.containsKey(property);
- PropertyBuilder propertyBuilder = propertyNameToPropertyBuilder.get(property);
- boolean hasBuilder = propertyBuilder != null;
- if (hasBuilder) {
- // If property bar of type Bar has a barBuilder() that returns BarBuilder, then it must
- // be possible to make a BarBuilder from a Bar if either (1) the @AutoValue class has a
- // toBuilder() or (2) there is also a setBar(Bar). Making BarBuilder from Bar is
- // possible if Bar either has a toBuilder() method or BarBuilder has an addAll or putAll
- // method that accepts a Bar argument.
- boolean canMakeBarBuilder =
- (propertyBuilder.getBuiltToBuilder() != null
- || propertyBuilder.getCopyAll() != null);
- boolean needToMakeBarBuilder = (autoValueHasToBuilder || hasSetter);
- if (needToMakeBarBuilder && !canMakeBarBuilder) {
- errorReporter.reportError(
- propertyBuilder.getPropertyBuilderMethod(),
- "[AutoValueCantMakeBuilder] Property builder method returns %1$s but there is no"
- + " way to make that type from %2$s: %2$s does not have a non-static"
- + " toBuilder() method that returns %1$s, and %1$s does not have a method"
- + " addAll or putAll that accepts an argument of type %2$s",
- propertyBuilder.getBuilderTypeMirror(),
- propertyType);
- }
- } else if (!hasSetter) {
- // We have neither barBuilder() nor setBar(Bar), so we should complain.
- String setterName = settersPrefixed ? prefixWithSet(property) : property;
- errorReporter.reportError(
- builderType,
- "[AutoValueBuilderMissingMethod] Expected a method with this signature: %s%s"
- + " %s(%s), or a %sBuilder() method",
- builderType,
- typeParamsString(),
- setterName,
- propertyType,
- property);
- }
- });
+ for (String property : rewrittenPropertyTypes.keySet()) {
+ TypeMirror propertyType = rewrittenPropertyTypes.get(property);
+ boolean hasSetter = propertyNameToSetter.containsKey(property);
+ PropertyBuilder propertyBuilder = propertyNameToPropertyBuilder.get(property);
+ boolean hasBuilder = propertyBuilder != null;
+ if (hasBuilder) {
+ // If property bar of type Bar has a barBuilder() that returns BarBuilder, then it must
+ // be possible to make a BarBuilder from a Bar if either (1) the @AutoValue class has a
+ // toBuilder() or (2) there is also a setBar(Bar). Making BarBuilder from Bar is
+ // possible if Bar either has a toBuilder() method or BarBuilder has an addAll or putAll
+ // method that accepts a Bar argument.
+ boolean canMakeBarBuilder =
+ (propertyBuilder.getBuiltToBuilder() != null || propertyBuilder.getCopyAll() != null);
+ boolean needToMakeBarBuilder = (autoValueHasToBuilder || hasSetter);
+ if (needToMakeBarBuilder && !canMakeBarBuilder) {
+ errorReporter.reportError(
+ propertyBuilder.getPropertyBuilderMethod(),
+ "[AutoValueCantMakeBuilder] Property builder method returns %1$s but there is no"
+ + " way to make that type from %2$s: %2$s does not have a non-static"
+ + " toBuilder() method that returns %1$s, and %1$s does not have a method"
+ + " addAll or putAll that accepts an argument of type %2$s",
+ propertyBuilder.getBuilderTypeMirror(),
+ propertyType);
+ }
+ } else if (!hasSetter) {
+ // We have neither barBuilder() nor setBar(Bar), so we should complain.
+ String setterName = settersPrefixed ? prefixWithSet(property) : property;
+ errorReporter.reportError(
+ builderType,
+ "[%sBuilderMissingMethod] Expected a method with this signature: %s"
+ + " %s(%s), or a %sBuilder() method",
+ autoWhat(),
+ builderType.asType(),
+ setterName,
+ propertyType,
+ property);
+ }
+ }
return errorReporter.errorCount() == startErrorCount;
}
@@ -255,7 +221,7 @@
break;
default:
errorReporter.reportError(
- method, "[AutoValueBuilderArgs] Builder methods must have 0 or 1 parameters");
+ method, "[%sBuilderArgs] Builder methods must have 0 or 1 parameters", autoWhat());
}
}
@@ -268,26 +234,26 @@
* ImmutableList<String> foos()} or {@code getFoos()}.
*/
private void classifyMethodNoArgs(ExecutableElement method) {
- String methodName = method.getSimpleName().toString();
- TypeMirror returnType = builderMethodReturnType(method);
-
- ExecutableElement getter = getterNameToGetter.get(methodName);
- if (getter != null) {
- classifyGetter(method, getter);
+ Optional<String> getterProperty = propertyForBuilderGetter(method);
+ if (getterProperty.isPresent()) {
+ classifyGetter(method, getterProperty.get());
return;
}
+ String methodName = method.getSimpleName().toString();
+ TypeMirror returnType = builderMethodReturnType(method);
+
if (methodName.endsWith("Builder")) {
String property = methodName.substring(0, methodName.length() - "Builder".length());
- if (getterToPropertyName.containsValue(property)) {
+ if (rewrittenPropertyTypes.containsKey(property)) {
PropertyBuilderClassifier propertyBuilderClassifier =
new PropertyBuilderClassifier(
errorReporter,
typeUtils,
elementUtils,
this,
- getterToPropertyName,
- getterToPropertyType,
+ this::propertyIsNullable,
+ rewrittenPropertyTypes,
eclipseHack);
Optional<PropertyBuilder> propertyBuilder =
propertyBuilderClassifier.makePropertyBuilder(method, property);
@@ -298,22 +264,24 @@
}
}
- if (TYPE_EQUIVALENCE.equivalent(returnType, autoValueClass.asType())) {
+ if (TYPE_EQUIVALENCE.equivalent(returnType, builtType)) {
buildMethods.add(method);
} else {
errorReporter.reportError(
method,
- "[AutoValueBuilderNoArg] Method without arguments should be a build method returning"
- + " %1$s%2$s, or a getter method with the same name and type as a getter method of"
- + " %1$s, or fooBuilder() where foo() or getFoo() is a getter method of %1$s",
- autoValueClass,
- typeParamsString());
+ "[%1$sBuilderNoArg] Method without arguments should be a build method returning"
+ + " %2$s, or a getter method with the same name and type as %3$s,"
+ + " or fooBuilder() where %4$s is %3$s",
+ // "where foo() or getFoo() is a method in..." or "where foo is a parameter of..."
+ autoWhat(),
+ builtType,
+ getterMustMatch(),
+ fooBuilderMustMatch());
}
}
- private void classifyGetter(ExecutableElement builderGetter, ExecutableElement originalGetter) {
- String propertyName = getterToPropertyName.get(originalGetter);
- TypeMirror originalGetterType = getterToPropertyType.get(originalGetter);
+ private void classifyGetter(ExecutableElement builderGetter, String propertyName) {
+ TypeMirror originalGetterType = rewrittenPropertyTypes.get(propertyName);
TypeMirror builderGetterType = builderMethodReturnType(builderGetter);
String builderGetterTypeString = TypeEncoder.encodeWithAnnotations(builderGetterType);
if (TYPE_EQUIVALENCE.equivalent(builderGetterType, originalGetterType)) {
@@ -344,51 +312,76 @@
builderGetter,
"[AutoValueBuilderReturnType] Method matches a property of %1$s but has return type %2$s"
+ " instead of %3$s or an Optional wrapping of %3$s",
- autoValueClass,
+ builtType,
builderGetterType,
originalGetterType);
}
/**
- * Classifies a method given that it has one argument. Currently, a method with one argument can
- * only be a setter, meaning that it must look like {@code foo(T)} or {@code setFoo(T)}, where the
- * {@code AutoValue} class has a property called {@code foo} of type {@code T}.
+ * Classifies a method given that it has one argument. A method with one argument can be:
+ *
+ * <ul>
+ * <li>a setter, meaning that it looks like {@code foo(T)} or {@code setFoo(T)}, where the
+ * {@code AutoValue} class has a property called {@code foo} of type {@code T};
+ * <li>a property builder with one argument, meaning it looks like {@code
+ * ImmutableSortedSet.Builder<V> foosBuilder(Comparator<V>)}, where the {@code AutoValue}
+ * class has a property called {@code foos} with a type whose builder can be made with an
+ * argument of the given type.
+ * </ul>
*/
private void classifyMethodOneArg(ExecutableElement method) {
+ if (classifyPropertyBuilderOneArg(method)) {
+ return;
+ }
String methodName = method.getSimpleName().toString();
- Map<String, ExecutableElement> propertyNameToGetter = getterToPropertyName.inverse();
+ ImmutableMap<String, E> propertyElements = propertyElements();
String propertyName = null;
- ExecutableElement valueGetter = propertyNameToGetter.get(methodName);
+ E propertyElement = propertyElements.get(methodName);
Multimap<String, PropertySetter> propertyNameToSetters = null;
- if (valueGetter != null) {
+ if (propertyElement != null) {
propertyNameToSetters = propertyNameToUnprefixedSetters;
propertyName = methodName;
- } else if (valueGetter == null && methodName.startsWith("set") && methodName.length() > 3) {
+ } else if (methodName.startsWith("set") && methodName.length() > 3) {
propertyNameToSetters = propertyNameToPrefixedSetters;
propertyName = PropertyNames.decapitalizeLikeJavaBeans(methodName.substring(3));
- valueGetter = propertyNameToGetter.get(propertyName);
- if (valueGetter == null) {
+ propertyElement = propertyElements.get(propertyName);
+ if (propertyElement == null) {
// If our property is defined by a getter called getOAuth() then it is called "OAuth"
- // because of Introspector.decapitalize. Therefore we want Introspector.decapitalize to
- // be used for the setter too, so that you can write setOAuth(x). Meanwhile if the property
- // is defined by a getter called oAuth() then it is called "oAuth", but you would still
- // expect to be able to set it using setOAuth(x). Hence the second try using a decapitalize
- // method without the quirky two-leading-capitals rule.
+ // because of JavaBeans rules. Therefore we want JavaBeans rules to be used for the setter
+ // too, so that you can write setOAuth(x). Meanwhile if the property is defined by a getter
+ // called oAuth() then it is called "oAuth", but you would still expect to be able to set it
+ // using setOAuth(x). Hence the second try using a decapitalize method without the quirky
+ // two-leading-capitals rule.
propertyName = PropertyNames.decapitalizeNormally(methodName.substring(3));
- valueGetter = propertyNameToGetter.get(propertyName);
+ propertyElement = propertyElements.get(propertyName);
+ }
+ } else {
+ // We might also have an unprefixed setter, so the getter is called OAuth() or getOAuth() and
+ // the setter is called oAuth(x), where again JavaBeans rules imply that it should be called
+ // OAuth(x). Iterating over the properties here is a bit clunky but this case should be
+ // unusual.
+ propertyNameToSetters = propertyNameToUnprefixedSetters;
+ for (Map.Entry<String, E> entry : propertyElements.entrySet()) {
+ if (methodName.equals(PropertyNames.decapitalizeNormally(entry.getKey()))) {
+ propertyName = entry.getKey();
+ propertyElement = entry.getValue();
+ break;
+ }
}
}
- if (valueGetter == null || propertyNameToSetters == null) {
+ if (propertyElement == null || propertyNameToSetters == null) {
// The second disjunct isn't needed but convinces control-flow checkers that
// propertyNameToSetters can't be null when we call put on it below.
errorReporter.reportError(
method,
- "[AutoValueBuilderWhatProp] Method does not correspond to a property of %s",
- autoValueClass);
+ "[%sBuilderWhatProp] Method %s does not correspond to %s",
+ autoWhat(),
+ methodName,
+ getterMustMatch());
checkForFailedJavaBean(method);
return;
}
- Optional<Copier> function = getSetterFunction(valueGetter, method);
+ Optional<Copier> function = getSetterFunction(propertyElement, method);
if (function.isPresent()) {
DeclaredType builderTypeMirror = MoreTypes.asDeclared(builderType.asType());
ExecutableType methodMirror =
@@ -399,28 +392,44 @@
propertyName, new PropertySetter(method, parameterType, function.get()));
} else {
errorReporter.reportError(
- method, "Setter methods must return %s%s", builderType, typeParamsString());
+ method,
+ "[%sBuilderRet] Setter methods must return %s",
+ autoWhat(),
+ builderType.asType());
}
}
}
- // A frequent source of problems is where the JavaBeans conventions have been followed for
- // most but not all getters. Then AutoValue considers that they haven't been followed at all,
- // so you might have a property called getFoo where you thought it was called just foo, and
- // you might not understand why your setter called setFoo is rejected (it would have to be called
- // setGetFoo).
- private void checkForFailedJavaBean(ExecutableElement rejectedSetter) {
- ImmutableSet<ExecutableElement> allGetters = getterToPropertyName.keySet();
- ImmutableSet<ExecutableElement> prefixedGetters =
- AutoValueProcessor.prefixedGettersIn(allGetters);
- if (prefixedGetters.size() < allGetters.size()
- && prefixedGetters.size() >= allGetters.size() / 2) {
- errorReporter.reportNote(
- rejectedSetter,
- "This might be because you are using the getFoo() convention"
- + " for some but not all methods. These methods don't follow the convention: %s",
- difference(allGetters, prefixedGetters));
+ /**
+ * Classifies a method given that it has one argument and is a property builder with a parameter,
+ * like {@code ImmutableSortedSet.Builder<String> foosBuilder(Comparator<String>)}.
+ *
+ * @param method A method to classify
+ * @return true if method has been classified successfully
+ */
+ private boolean classifyPropertyBuilderOneArg(ExecutableElement method) {
+ String methodName = method.getSimpleName().toString();
+ if (!methodName.endsWith("Builder")) {
+ return false;
}
+ String property = methodName.substring(0, methodName.length() - "Builder".length());
+ if (!rewrittenPropertyTypes.containsKey(property)) {
+ return false;
+ }
+ PropertyBuilderClassifier propertyBuilderClassifier =
+ new PropertyBuilderClassifier(
+ errorReporter,
+ typeUtils,
+ elementUtils,
+ this,
+ this::propertyIsNullable,
+ rewrittenPropertyTypes,
+ eclipseHack);
+ Optional<PropertyBuilder> maybePropertyBuilder =
+ propertyBuilderClassifier.makePropertyBuilder(method, property);
+ maybePropertyBuilder.ifPresent(
+ propertyBuilder -> propertyNameToPropertyBuilder.put(property, propertyBuilder));
+ return maybePropertyBuilder.isPresent();
}
/**
@@ -431,12 +440,12 @@
* using a method like {@code ImmutableList.copyOf} or {@code Optional.of}, when the returned
* function will be something like {@code s -> "Optional.of(" + s + ")"}.
*/
- private Optional<Copier> getSetterFunction(
- ExecutableElement valueGetter, ExecutableElement setter) {
+ private Optional<Copier> getSetterFunction(E propertyElement, ExecutableElement setter) {
VariableElement parameterElement = Iterables.getOnlyElement(setter.getParameters());
boolean nullableParameter =
nullableAnnotationFor(parameterElement, parameterElement.asType()).isPresent();
- TypeMirror targetType = getterToPropertyType.get(valueGetter);
+ String property = propertyElements().inverse().get(propertyElement);
+ TypeMirror targetType = rewrittenPropertyTypes.get(property);
ExecutableType finalSetter =
MoreTypes.asExecutable(
typeUtils.asMemberOf(MoreTypes.asDeclared(builderType.asType()), setter));
@@ -448,14 +457,14 @@
&& typeUtils.isAssignable(targetType, parameterType)) {
if (nullableParameter) {
boolean nullableProperty =
- nullableAnnotationFor(valueGetter, valueGetter.getReturnType()).isPresent();
+ nullableAnnotationFor(propertyElement, originalPropertyType(propertyElement))
+ .isPresent();
if (!nullableProperty) {
errorReporter.reportError(
setter,
- "[AutoValueNullNotNull] Parameter of setter method is @Nullable but property method"
- + " %s.%s() is not",
- autoValueClass,
- valueGetter.getSimpleName());
+ "[%sNullNotNull] Parameter of setter method is @Nullable but %s is not",
+ autoWhat(),
+ propertyString(propertyElement));
return Optional.empty();
}
}
@@ -465,12 +474,15 @@
// Parameter type is not equal to property type, but might be convertible with copyOf.
ImmutableList<ExecutableElement> copyOfMethods = copyOfMethods(targetType, nullableParameter);
if (!copyOfMethods.isEmpty()) {
- return getConvertingSetterFunction(copyOfMethods, valueGetter, setter, parameterType);
+ return getConvertingSetterFunction(copyOfMethods, propertyElement, setter, parameterType);
}
errorReporter.reportError(
setter,
- "[AutoValueGetVsSet] Parameter type %s of setter method should be %s to match getter %s.%s",
- parameterType, targetType, autoValueClass, valueGetter.getSimpleName());
+ "[%sGetVsSet] Parameter type %s of setter method should be %s to match %s",
+ autoWhat(),
+ parameterType,
+ targetType,
+ propertyString(propertyElement));
return Optional.empty();
}
@@ -481,10 +493,11 @@
*/
private Optional<Copier> getConvertingSetterFunction(
ImmutableList<ExecutableElement> copyOfMethods,
- ExecutableElement valueGetter,
+ E propertyElement,
ExecutableElement setter,
TypeMirror parameterType) {
- DeclaredType targetType = MoreTypes.asDeclared(getterToPropertyType.get(valueGetter));
+ String property = propertyElements().inverse().get(propertyElement);
+ DeclaredType targetType = MoreTypes.asDeclared(rewrittenPropertyTypes.get(property));
for (ExecutableElement copyOfMethod : copyOfMethods) {
Optional<Copier> function =
getConvertingSetterFunction(copyOfMethod, targetType, parameterType);
@@ -495,12 +508,12 @@
String targetTypeSimpleName = targetType.asElement().getSimpleName().toString();
errorReporter.reportError(
setter,
- "[AutoValueGetVsSetOrConvert] Parameter type %s of setter method should be %s to match"
- + " getter %s.%s, or it should be a type that can be passed to %s.%s to produce %s",
+ "[%sGetVsSetOrConvert] Parameter type %s of setter method should be %s to match %s, or it"
+ + " should be a type that can be passed to %s.%s to produce %s",
+ autoWhat(),
parameterType,
targetType,
- autoValueClass,
- valueGetter.getSimpleName(),
+ propertyString(propertyElement),
targetTypeSimpleName,
copyOfMethods.get(0).getSimpleName(),
targetType);
@@ -635,7 +648,76 @@
return "set" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
}
- private String typeParamsString() {
- return TypeSimplifier.actualTypeParametersString(autoValueClass);
+ /**
+ * True if the given property is nullable, either because its type has a {@code @Nullable} type
+ * annotation, or because its getter method has a {@code @Nullable} method annotation.
+ */
+ private boolean propertyIsNullable(String property) {
+ E propertyElement = propertyElements().get(property);
+ return Stream.of(propertyElement, originalPropertyType(propertyElement))
+ .flatMap(ac -> ac.getAnnotationMirrors().stream())
+ .map(a -> a.getAnnotationType().asElement().getSimpleName())
+ .anyMatch(n -> n.contentEquals("Nullable"));
}
+
+ /**
+ * Returns a map from property names to the corresponding source program elements. For AutoValue,
+ * these elements are the abstract getter methods in the {@code @AutoValue} class. For
+ * AutoBuilder, they are the parameters of the constructor or method that the generated builder
+ * will call.
+ */
+ abstract ImmutableBiMap<String, E> propertyElements();
+
+ /**
+ * Returns the property type as it appears on the original source program element. This can be
+ * different from the type stored in {@link #rewrittenPropertyTypes} since that one will refer to
+ * type variables in the builder rather than in the original class. Also, {@link
+ * #rewrittenPropertyTypes} will not have type annotations even if they were present on the
+ * original element, so {@code originalPropertyType} is the right thing to use for those.
+ */
+ abstract TypeMirror originalPropertyType(E propertyElement);
+
+ /**
+ * A string identifying the given property element, which is a method for AutoValue or a parameter
+ * for AutoBuilder.
+ */
+ abstract String propertyString(E propertyElement);
+
+ /**
+ * Returns the name of the property that the given no-arg builder method queries, if
+ * any. For example, if your {@code @AutoValue} class has a method {@code abstract String
+ * getBar()} then an abstract method in its builder with the same signature will query the {@code
+ * bar} property.
+ */
+ abstract Optional<String> propertyForBuilderGetter(ExecutableElement method);
+
+ /**
+ * Checks for failed JavaBean usage when a method that looks like a setter doesn't actually match
+ * anything, and emits a compiler Note if detected. A frequent source of problems is where the
+ * JavaBeans conventions have been followed for most but not all getters. Then AutoValue considers
+ * that they haven't been followed at all, so you might have a property called getFoo where you
+ * thought it was called just foo, and you might not understand why your setter called setFoo is
+ * rejected (it would have to be called setGetFoo).
+ *
+ * <p>This is not relevant for AutoBuilder, which uses parameter names rather than getters. The
+ * parameter names are unambiguously the same as the property names.
+ */
+ abstract void checkForFailedJavaBean(ExecutableElement rejectedSetter);
+
+ /**
+ * A string describing what sort of Auto this is, {@code "AutoValue"} or {@code "AutoBuilder"}.
+ */
+ abstract String autoWhat();
+
+ /**
+ * A string describing what a builder getter must match: a property method for AutoValue, a
+ * parameter for AutoBuilder.
+ */
+ abstract String getterMustMatch();
+
+ /**
+ * A string describing what a property builder for property {@code foo} must match, {@code foo()
+ * or getFoo()} for AutoValue, {@code foo} for AutoBuilder.
+ */
+ abstract String fooBuilderMustMatch();
}
diff --git a/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifierForAutoBuilder.java b/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifierForAutoBuilder.java
new file mode 100644
index 0000000..55a3198
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifierForAutoBuilder.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import static com.google.auto.common.MoreStreams.toImmutableBiMap;
+import static com.google.auto.common.MoreStreams.toImmutableMap;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Equivalence;
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.util.Types;
+
+class BuilderMethodClassifierForAutoBuilder extends BuilderMethodClassifier<VariableElement> {
+ private final ExecutableElement executable;
+ private final ImmutableBiMap<VariableElement, String> paramToPropertyName;
+
+ private BuilderMethodClassifierForAutoBuilder(
+ ErrorReporter errorReporter,
+ ProcessingEnvironment processingEnv,
+ ExecutableElement executable,
+ TypeMirror builtType,
+ TypeElement builderType,
+ ImmutableBiMap<VariableElement, String> paramToPropertyName,
+ ImmutableMap<String, TypeMirror> rewrittenPropertyTypes) {
+ super(errorReporter, processingEnv, builtType, builderType, rewrittenPropertyTypes);
+ this.executable = executable;
+ this.paramToPropertyName = paramToPropertyName;
+ }
+
+ /**
+ * Classifies the given methods from a builder type and its ancestors.
+ *
+ * @param methods the abstract methods in {@code builderType} and its ancestors.
+ * @param errorReporter where to report errors.
+ * @param processingEnv the ProcessingEnvironment for annotation processing.
+ * @param executable the constructor or static method that AutoBuilder will call.
+ * @param builtType the type to be built.
+ * @param builderType the builder class or interface within {@code ofClass}.
+ * @return an {@code Optional} that contains the results of the classification if it was
+ * successful or nothing if it was not.
+ */
+ static Optional<BuilderMethodClassifier<VariableElement>> classify(
+ Iterable<ExecutableElement> methods,
+ ErrorReporter errorReporter,
+ ProcessingEnvironment processingEnv,
+ ExecutableElement executable,
+ TypeMirror builtType,
+ TypeElement builderType) {
+ ImmutableBiMap<VariableElement, String> paramToPropertyName =
+ executable.getParameters().stream()
+ .collect(toImmutableBiMap(v -> v, v -> v.getSimpleName().toString()));
+ ImmutableMap<String, TypeMirror> rewrittenPropertyTypes =
+ rewriteParameterTypes(executable, builderType, errorReporter, processingEnv.getTypeUtils());
+ BuilderMethodClassifier<VariableElement> classifier =
+ new BuilderMethodClassifierForAutoBuilder(
+ errorReporter,
+ processingEnv,
+ executable,
+ builtType,
+ builderType,
+ paramToPropertyName,
+ rewrittenPropertyTypes);
+ if (classifier.classifyMethods(methods, false)) {
+ return Optional.of(classifier);
+ } else {
+ return Optional.empty();
+ }
+ }
+
+ // Rewrites the parameter types of the executable so they use the type variables of the builder
+ // where appropriate.
+ //
+ // Suppose we have something like this:
+ //
+ // static <E> Set<E> singletonSet(E elem) {...}
+ //
+ // @AutoBuilder(callMethod = "singletonSet")
+ // interface SingletonSetBuilder<E> {
+ // SingletonSetBuilder<E> setElem(E elem);
+ // Set<E> build();
+ // }
+ //
+ // We want to check that the type of the setter `setElem` matches the type of the
+ // parameter it is setting. But in fact it doesn't: the type of the setter is
+ // E-of-SingletonSetBuilder while the type of the parameter is E-of-singletonSet. So we
+ // need to rewrite any type variables mentioned in parameters so that they use the corresponding
+ // types from the builder. We want to return a map where "elem" is mapped to
+ // E-of-SingletonSetBuilder, even though the `elem` that we get from the parameters of
+ // singletonSet is going to be E-of-singletonSet. And we also want that to work if the parameter
+ // is something more complicated, like List<? extends E>.
+ //
+ // For the corresponding situation with AutoValue, we have a way of dodging the problem somewhat.
+ // For an @AutoValue class Foo<E> with a builder Builder<E>, we can craft a DeclaredType
+ // Foo<E> where the E comes from Builder<E>, and we can use Types.asMemberOf to determine the
+ // return types of methods (which are what we want to rewrite in that case). But that doesn't
+ // work here because singletonSet is static and Types.asMemberOf would have no effect on it.
+ //
+ // So instead we take the type of each parameter and feed it through a TypeVisitor that rewrites
+ // type variables, rewriting from E-of-singletonSet to E-of-SingletonSetBuilder. Then we can use
+ // Types.isSameType or Types.isAssignable and it will work as we expect.
+ //
+ // In principle a similar situation arises with the return type Set<E> of singletonSet versus
+ // the return type Set<E> of SingletonSetBuilder.build(). But in fact we only use
+ // MoreTypes.equivalence to compare those, and that returns true for distinct type variables if
+ // they have the same name and bounds.
+ private static ImmutableMap<String, TypeMirror> rewriteParameterTypes(
+ ExecutableElement executable,
+ TypeElement builderType,
+ ErrorReporter errorReporter,
+ Types typeUtils) {
+ ImmutableList<TypeParameterElement> executableTypeParams = executableTypeParams(executable);
+ List<? extends TypeParameterElement> builderTypeParams = builderType.getTypeParameters();
+ if (!BuilderSpec.sameTypeParameters(executableTypeParams, builderTypeParams)) {
+ errorReporter.abortWithError(
+ builderType,
+ "[AutoBuilderTypeParams] Builder type parameters %s must match type parameters %s of %s",
+ TypeEncoder.typeParametersString(builderTypeParams),
+ TypeEncoder.typeParametersString(executableTypeParams),
+ AutoBuilderProcessor.executableString(executable));
+ }
+ if (executableTypeParams.isEmpty()) {
+ // Optimization for a common case. No point in doing all that type visiting if we have no
+ // variables to substitute.
+ return executable.getParameters().stream()
+ .collect(toImmutableMap(v -> v.getSimpleName().toString(), Element::asType));
+ }
+ Map<Equivalence.Wrapper<TypeVariable>, TypeMirror> typeVariables = new LinkedHashMap<>();
+ for (int i = 0; i < executableTypeParams.size(); i++) {
+ TypeVariable from = MoreTypes.asTypeVariable(executableTypeParams.get(i).asType());
+ TypeVariable to = MoreTypes.asTypeVariable(builderTypeParams.get(i).asType());
+ typeVariables.put(MoreTypes.equivalence().wrap(from), to);
+ }
+ Function<TypeVariable, TypeMirror> substitute =
+ v -> typeVariables.get(MoreTypes.equivalence().wrap(v));
+ return executable.getParameters().stream()
+ .collect(
+ toImmutableMap(
+ v -> v.getSimpleName().toString(),
+ v -> TypeVariables.substituteTypeVariables(v.asType(), substitute, typeUtils)));
+ }
+
+ private static ImmutableList<TypeParameterElement> executableTypeParams(
+ ExecutableElement executable) {
+ switch (executable.getKind()) {
+ case CONSTRUCTOR:
+ // A constructor can have its own type parameters, in addition to any that its containing
+ // class has. That's pretty unusual, but we allow it, requiring the builder to have type
+ // parameters that are the concatenation of the class's and the constructor's.
+ TypeElement container = MoreElements.asType(executable.getEnclosingElement());
+ return ImmutableList.<TypeParameterElement>builder()
+ .addAll(container.getTypeParameters())
+ .addAll(executable.getTypeParameters())
+ .build();
+ case METHOD:
+ return ImmutableList.copyOf(executable.getTypeParameters());
+ default:
+ throw new VerifyException("Unexpected executable kind " + executable.getKind());
+ }
+ }
+
+ @Override
+ Optional<String> propertyForBuilderGetter(ExecutableElement method) {
+ String methodName = method.getSimpleName().toString();
+ if (paramToPropertyName.containsValue(methodName)) {
+ return Optional.of(methodName);
+ }
+ if (AutoValueishProcessor.isPrefixedGetter(method)) {
+ int prefixLength = methodName.startsWith("get") ? 3 : 2; // "get" or "is"
+ String unprefixed = methodName.substring(prefixLength);
+ String propertyName = PropertyNames.decapitalizeLikeJavaBeans(unprefixed);
+ if (paramToPropertyName.containsValue(propertyName)) {
+ return Optional.of(propertyName);
+ }
+ propertyName = PropertyNames.decapitalizeNormally(unprefixed);
+ if (paramToPropertyName.containsValue(propertyName)) {
+ return Optional.of(propertyName);
+ }
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ void checkForFailedJavaBean(ExecutableElement rejectedSetter) {}
+
+ @Override
+ ImmutableBiMap<String, VariableElement> propertyElements() {
+ return paramToPropertyName.inverse();
+ }
+
+ @Override
+ TypeMirror originalPropertyType(VariableElement propertyElement) {
+ return propertyElement.asType();
+ }
+
+ @Override
+ String propertyString(VariableElement propertyElement) {
+ return "parameter \""
+ + propertyElement.getSimpleName()
+ + "\" of "
+ + AutoBuilderProcessor.executableString(executable);
+ }
+
+ @Override
+ String autoWhat() {
+ return "AutoBuilder";
+ }
+
+ @Override
+ String getterMustMatch() {
+ return "a parameter of " + AutoBuilderProcessor.executableString(executable);
+ }
+
+ @Override
+ String fooBuilderMustMatch() {
+ return "foo";
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifierForAutoValue.java b/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifierForAutoValue.java
new file mode 100644
index 0000000..dde449b
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/BuilderMethodClassifierForAutoValue.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import static com.google.common.collect.Sets.difference;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import java.util.Optional;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+class BuilderMethodClassifierForAutoValue extends BuilderMethodClassifier<ExecutableElement> {
+ private final ErrorReporter errorReporter;
+ private final ImmutableBiMap<ExecutableElement, String> getterToPropertyName;
+ private final ImmutableMap<String, ExecutableElement> getterNameToGetter;
+ private final TypeMirror builtType;
+
+ private BuilderMethodClassifierForAutoValue(
+ ErrorReporter errorReporter,
+ ProcessingEnvironment processingEnv,
+ TypeMirror builtType,
+ TypeElement builderType,
+ ImmutableBiMap<ExecutableElement, String> getterToPropertyName,
+ ImmutableMap<String, TypeMirror> rewrittenPropertyTypes) {
+ super(errorReporter, processingEnv, builtType, builderType, rewrittenPropertyTypes);
+ this.errorReporter = errorReporter;
+ this.getterToPropertyName = getterToPropertyName;
+ this.getterNameToGetter =
+ Maps.uniqueIndex(getterToPropertyName.keySet(), m -> m.getSimpleName().toString());
+ this.builtType = builtType;
+ }
+
+ /**
+ * Classifies the given methods from a builder type and its ancestors.
+ *
+ * @param methods the abstract methods in {@code builderType} and its ancestors.
+ * @param errorReporter where to report errors.
+ * @param processingEnv the {@link ProcessingEnvironment} for annotation processing.
+ * @param autoValueClass the {@code AutoValue} class containing the builder.
+ * @param builderType the builder class or interface within {@code autoValueClass}.
+ * @param getterToPropertyName a map from getter methods to the properties they get.
+ * @param rewrittenPropertyTypes a map from property names to types. The types here use type
+ * parameters from the builder class (if any) rather than from the {@code AutoValue} class,
+ * even though the getter methods are in the latter.
+ * @param autoValueHasToBuilder true if the containing {@code @AutoValue} class has a {@code
+ * toBuilder()} method.
+ * @return an {@code Optional} that contains the results of the classification if it was
+ * successful or nothing if it was not.
+ */
+ static Optional<BuilderMethodClassifier<ExecutableElement>> classify(
+ Iterable<ExecutableElement> methods,
+ ErrorReporter errorReporter,
+ ProcessingEnvironment processingEnv,
+ TypeElement autoValueClass,
+ TypeElement builderType,
+ ImmutableBiMap<ExecutableElement, String> getterToPropertyName,
+ ImmutableMap<String, TypeMirror> rewrittenPropertyTypes,
+ boolean autoValueHasToBuilder) {
+ BuilderMethodClassifier<ExecutableElement> classifier =
+ new BuilderMethodClassifierForAutoValue(
+ errorReporter,
+ processingEnv,
+ autoValueClass.asType(),
+ builderType,
+ getterToPropertyName,
+ rewrittenPropertyTypes);
+ if (classifier.classifyMethods(methods, autoValueHasToBuilder)) {
+ return Optional.of(classifier);
+ } else {
+ return Optional.empty();
+ }
+ }
+
+ @Override
+ TypeMirror originalPropertyType(ExecutableElement propertyElement) {
+ return propertyElement.getReturnType();
+ }
+
+ @Override
+ String propertyString(ExecutableElement propertyElement) {
+ TypeElement type = MoreElements.asType(propertyElement.getEnclosingElement());
+ return "property method "
+ + type.getQualifiedName()
+ + "."
+ + propertyElement.getSimpleName()
+ + "()";
+ }
+
+ @Override
+ ImmutableBiMap<String, ExecutableElement> propertyElements() {
+ return getterToPropertyName.inverse();
+ }
+
+ @Override
+ Optional<String> propertyForBuilderGetter(ExecutableElement method) {
+ String methodName = method.getSimpleName().toString();
+ return Optional.ofNullable(getterNameToGetter.get(methodName)).map(getterToPropertyName::get);
+ }
+
+ @Override
+ void checkForFailedJavaBean(ExecutableElement rejectedSetter) {
+ ImmutableSet<ExecutableElement> allGetters = getterToPropertyName.keySet();
+ ImmutableSet<ExecutableElement> prefixedGetters =
+ AutoValueProcessor.prefixedGettersIn(allGetters);
+ if (prefixedGetters.size() < allGetters.size()
+ && prefixedGetters.size() >= allGetters.size() / 2) {
+ errorReporter.reportNote(
+ rejectedSetter,
+ "This might be because you are using the getFoo() convention"
+ + " for some but not all methods. These methods don't follow the convention: %s",
+ difference(allGetters, prefixedGetters));
+ }
+ }
+
+ @Override
+ String autoWhat() {
+ return "AutoValue";
+ }
+
+ @Override
+ String getterMustMatch() {
+ return "a property method of " + builtType;
+ }
+
+ @Override
+ String fooBuilderMustMatch() {
+ return "foo() or getFoo()";
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/BuilderSpec.java b/value/src/main/java/com/google/auto/value/processor/BuilderSpec.java
index 7e5b17c..9f45d17 100644
--- a/value/src/main/java/com/google/auto/value/processor/BuilderSpec.java
+++ b/value/src/main/java/com/google/auto/value/processor/BuilderSpec.java
@@ -16,8 +16,9 @@
package com.google.auto.value.processor;
import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
-import static com.google.auto.value.processor.AutoValueOrOneOfProcessor.hasAnnotationMirror;
-import static com.google.auto.value.processor.AutoValueOrOneOfProcessor.nullableAnnotationFor;
+import static com.google.auto.common.MoreStreams.toImmutableSet;
+import static com.google.auto.value.processor.AutoValueishProcessor.hasAnnotationMirror;
+import static com.google.auto.value.processor.AutoValueishProcessor.nullableAnnotationFor;
import static com.google.auto.value.processor.ClassNames.AUTO_VALUE_BUILDER_NAME;
import static com.google.common.collect.Sets.immutableEnumSet;
import static java.util.stream.Collectors.toList;
@@ -25,16 +26,16 @@
import static javax.lang.model.util.ElementFilter.methodsIn;
import static javax.lang.model.util.ElementFilter.typesIn;
+import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.auto.value.extension.AutoValueExtension;
-import com.google.auto.value.processor.AutoValueOrOneOfProcessor.Property;
+import com.google.auto.value.processor.AutoValueishProcessor.Property;
import com.google.auto.value.processor.PropertyBuilderClassifier.PropertyBuilder;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
-import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -49,6 +50,7 @@
import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Types;
@@ -117,7 +119,7 @@
private final TypeElement builderTypeElement;
private ImmutableSet<ExecutableElement> toBuilderMethods;
private ExecutableElement buildMethod;
- private BuilderMethodClassifier classifier;
+ private BuilderMethodClassifier<?> classifier;
Builder(TypeElement builderTypeElement) {
this.builderTypeElement = builderTypeElement;
@@ -142,14 +144,23 @@
@Override
public Optional<ExecutableElement> buildMethod() {
- return methodsIn(builderTypeElement.getEnclosedElements()).stream()
+ Types typeUtils = processingEnv.getTypeUtils();
+ DeclaredType builderTypeMirror = MoreTypes.asDeclared(builderTypeElement.asType());
+ return MoreElements.getLocalAndInheritedMethods(
+ builderTypeElement, typeUtils, processingEnv.getElementUtils())
+ .stream()
.filter(
m ->
m.getSimpleName().contentEquals("build")
&& !m.getModifiers().contains(Modifier.PRIVATE)
&& !m.getModifiers().contains(Modifier.STATIC)
- && m.getParameters().isEmpty()
- && erasedTypeIs(m.getReturnType(), autoValueClass))
+ && m.getParameters().isEmpty())
+ .filter(
+ m -> {
+ ExecutableType methodMirror =
+ MoreTypes.asExecutable(typeUtils.asMemberOf(builderTypeMirror, m));
+ return erasedTypeIs(methodMirror.getReturnType(), autoValueClass);
+ })
.findFirst();
}
@@ -186,7 +197,8 @@
* Finds any methods in the set that return the builder type. If the builder has type parameters
* {@code <A, B>}, then the return type of the method must be {@code Builder<A, B>} with the
* same parameter names. We enforce elsewhere that the names and bounds of the builder
- * parameters must be the same as those of the @AutoValue class. Here's a correct example:
+ * parameters must be the same as those of the {@code @AutoValue} class. Here's a correct
+ * example:
*
* <pre>
* {@code @AutoValue abstract class Foo<A extends Number, B> {
@@ -201,18 +213,25 @@
* <p>We currently impose that there cannot be more than one such method.
*/
ImmutableSet<ExecutableElement> toBuilderMethods(
- Types typeUtils, Set<ExecutableElement> abstractMethods) {
+ Types typeUtils, TypeElement autoValueType, Set<ExecutableElement> abstractMethods) {
List<String> builderTypeParamNames =
builderTypeElement.getTypeParameters().stream()
.map(e -> e.getSimpleName().toString())
.collect(toList());
+ DeclaredType autoValueTypeMirror = MoreTypes.asDeclared(autoValueType.asType());
ImmutableSet.Builder<ExecutableElement> methods = ImmutableSet.builder();
for (ExecutableElement method : abstractMethods) {
- if (builderTypeElement.equals(typeUtils.asElement(method.getReturnType()))) {
+ 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(method.getReturnType());
+ DeclaredType returnType = MoreTypes.asDeclared(returnTypeMirror);
List<String> typeArguments =
returnType.getTypeArguments().stream()
.filter(t -> t.getKind().equals(TypeKind.TYPEVAR))
@@ -237,11 +256,12 @@
return builderMethods;
}
- void defineVars(
- AutoValueTemplateVars vars,
+ void defineVarsForAutoValue(
+ AutoValueOrBuilderTemplateVars vars,
ImmutableBiMap<ExecutableElement, String> getterToPropertyName) {
- Iterable<ExecutableElement> builderMethods = abstractMethods(builderTypeElement);
- boolean autoValueHasToBuilder = !toBuilderMethods.isEmpty();
+ Iterable<ExecutableElement> builderMethods =
+ abstractMethods(builderTypeElement, processingEnv);
+ boolean autoValueHasToBuilder = toBuilderMethods != null && !toBuilderMethods.isEmpty();
ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType =
TypeVariables.rewriteReturnTypes(
processingEnv.getElementUtils(),
@@ -249,32 +269,40 @@
getterToPropertyName.keySet(),
autoValueClass,
builderTypeElement);
- Optional<BuilderMethodClassifier> optionalClassifier =
- BuilderMethodClassifier.classify(
+ ImmutableMap.Builder<String, TypeMirror> rewrittenPropertyTypes = ImmutableMap.builder();
+ getterToPropertyType.forEach(
+ (getter, type) -> rewrittenPropertyTypes.put(getterToPropertyName.get(getter), type));
+ Optional<BuilderMethodClassifier<ExecutableElement>> optionalClassifier =
+ BuilderMethodClassifierForAutoValue.classify(
builderMethods,
errorReporter,
processingEnv,
autoValueClass,
builderTypeElement,
getterToPropertyName,
- getterToPropertyType,
+ rewrittenPropertyTypes.build(),
autoValueHasToBuilder);
if (!optionalClassifier.isPresent()) {
return;
}
for (ExecutableElement method : methodsIn(builderTypeElement.getEnclosedElements())) {
if (method.getSimpleName().contentEquals("builder")
- && method.getModifiers().contains(Modifier.STATIC)
- && method.getAnnotationMirrors().isEmpty()) {
- // For now we ignore methods with annotations, because for example we do want to allow
- // Jackson's @JsonCreator.
+ && 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");
}
}
- this.classifier = optionalClassifier.get();
+ defineVars(vars, optionalClassifier.get());
+ }
+
+ void defineVars(AutoValueOrBuilderTemplateVars vars, BuilderMethodClassifier<?> classifier) {
+ this.classifier = classifier;
Set<ExecutableElement> buildMethods = classifier.buildMethods();
if (buildMethods.size() != 1) {
Set<? extends Element> errorElements =
@@ -282,8 +310,8 @@
for (Element buildMethod : errorElements) {
errorReporter.reportError(
buildMethod,
- "[AutoValueBuilderBuild] Builder must have a single no-argument method returning"
- + " %s%s",
+ "[AutoValueBuilderBuild] Builder must have a single no-argument method, typically"
+ + " called build(), that returns %s%s",
autoValueClass,
typeParamsString());
}
@@ -292,7 +320,8 @@
this.buildMethod = Iterables.getOnlyElement(buildMethods);
vars.builderIsInterface = builderTypeElement.getKind() == ElementKind.INTERFACE;
vars.builderTypeName = TypeSimplifier.classNameOf(builderTypeElement);
- vars.builderFormalTypes = TypeEncoder.formalTypeParametersString(builderTypeElement);
+ vars.builderFormalTypes =
+ TypeEncoder.typeParametersString(builderTypeElement.getTypeParameters());
vars.builderActualTypes = TypeSimplifier.actualTypeParametersString(builderTypeElement);
vars.buildMethod = Optional.of(new SimpleMethod(buildMethod));
vars.builderGetters = classifier.builderGetters();
@@ -301,15 +330,12 @@
vars.builderPropertyBuilders =
ImmutableMap.copyOf(classifier.propertyNameToPropertyBuilder());
- Set<Property> required = new LinkedHashSet<>(vars.props);
- for (Property property : vars.props) {
- if (property.isNullable()
- || property.getOptional() != null
- || vars.builderPropertyBuilders.containsKey(property.getName())) {
- required.remove(property);
- }
- }
- vars.builderRequiredProperties = ImmutableSet.copyOf(required);
+ vars.builderRequiredProperties =
+ vars.props.stream()
+ .filter(p -> !p.isNullable())
+ .filter(p -> p.getOptional() == null)
+ .filter(p -> !vars.builderPropertyBuilders.containsKey(p.getName()))
+ .collect(toImmutableSet());
}
}
@@ -325,6 +351,7 @@
* five) then {@code Optional<T>} 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;
@@ -342,11 +369,17 @@
* {@code Optional<T>} 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;
}
+ // Not accessed from templates so doesn't have to be public.
+ String getName() {
+ return name;
+ }
+
public String getAccess() {
return access;
}
@@ -361,8 +394,8 @@
}
/**
- * 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(...)}.
+ * 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);
@@ -452,7 +485,7 @@
return nullableAnnotation;
}
- public String copy(AutoValueProcessor.Property property) {
+ 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);
@@ -487,19 +520,24 @@
}
private static boolean sameTypeParameters(TypeElement a, TypeElement b) {
- int nTypeParameters = a.getTypeParameters().size();
- if (nTypeParameters != b.getTypeParameters().size()) {
+ return sameTypeParameters(a.getTypeParameters(), b.getTypeParameters());
+ }
+
+ static boolean sameTypeParameters(
+ List<? extends TypeParameterElement> aParams, List<? extends TypeParameterElement> bParams) {
+ int nTypeParameters = aParams.size();
+ if (nTypeParameters != bParams.size()) {
return false;
}
for (int i = 0; i < nTypeParameters; i++) {
- TypeParameterElement aParam = a.getTypeParameters().get(i);
- TypeParameterElement bParam = b.getTypeParameters().get(i);
+ TypeParameterElement aParam = aParams.get(i);
+ TypeParameterElement bParam = bParams.get(i);
if (!aParam.getSimpleName().equals(bParam.getSimpleName())) {
return false;
}
- Set<TypeMirror> autoValueBounds = new TypeMirrorSet(aParam.getBounds());
- Set<TypeMirror> builderBounds = new TypeMirrorSet(bParam.getBounds());
- if (!autoValueBounds.equals(builderBounds)) {
+ Set<TypeMirror> aBounds = new TypeMirrorSet(aParam.getBounds());
+ Set<TypeMirror> bBounds = new TypeMirrorSet(bParam.getBounds());
+ if (!aBounds.equals(bBounds)) {
return false;
}
}
@@ -512,7 +550,8 @@
* then this method will throw an exception that will cause us to defer processing of the current
* class until a later annotation-processing round.
*/
- private ImmutableSet<ExecutableElement> abstractMethods(TypeElement typeElement) {
+ static ImmutableSet<ExecutableElement> abstractMethods(
+ TypeElement typeElement, ProcessingEnvironment processingEnv) {
Set<ExecutableElement> methods =
getLocalAndInheritedMethods(
typeElement, processingEnv.getTypeUtils(), processingEnv.getElementUtils());
diff --git a/value/src/main/java/com/google/auto/value/processor/ClassNames.java b/value/src/main/java/com/google/auto/value/processor/ClassNames.java
index d23cfd2..76c5071 100644
--- a/value/src/main/java/com/google/auto/value/processor/ClassNames.java
+++ b/value/src/main/java/com/google/auto/value/processor/ClassNames.java
@@ -28,5 +28,7 @@
static final String AUTO_ONE_OF_NAME = AUTO_VALUE_PACKAGE_NAME + "AutoOneOf";
static final String AUTO_VALUE_NAME = AUTO_VALUE_PACKAGE_NAME + "AutoValue";
static final String AUTO_VALUE_BUILDER_NAME = AUTO_VALUE_NAME + ".Builder";
+ static final String AUTO_BUILDER_NAME = AUTO_VALUE_PACKAGE_NAME + "AutoBuilder";
static final String COPY_ANNOTATIONS_NAME = AUTO_VALUE_NAME + ".CopyAnnotations";
+ static final String KOTLIN_METADATA_NAME = "kotlin.Metadata";
}
diff --git a/value/src/main/java/com/google/auto/value/processor/ErrorReporter.java b/value/src/main/java/com/google/auto/value/processor/ErrorReporter.java
index e2a3d83..3ec9a0e 100644
--- a/value/src/main/java/com/google/auto/value/processor/ErrorReporter.java
+++ b/value/src/main/java/com/google/auto/value/processor/ErrorReporter.java
@@ -81,9 +81,12 @@
* @param e the element to which it pertains
* @param format the format string for the text of the error
* @param args arguments for the format string
+ * @return This method does not return, but is declared with an exception return type so you
+ * can write {@code throw abortWithError(...)} to tell the compiler that.
+ * @throws AbortProcessingException always
*/
@FormatMethod
- void abortWithError(Element e, String format, Object... args) {
+ AbortProcessingException abortWithError(Element e, String format, Object... args) {
reportError(e, format, args);
throw new AbortProcessingException();
}
diff --git a/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java b/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java
index 7220754..fae4e09 100644
--- a/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java
+++ b/value/src/main/java/com/google/auto/value/processor/GwtCompatibility.java
@@ -62,9 +62,7 @@
annotationArguments = "";
} else {
annotationArguments =
- getElementValues(annotation)
- .entrySet()
- .stream()
+ getElementValues(annotation).entrySet().stream()
.map(e -> e.getKey().getSimpleName() + " = " + e.getValue())
.collect(joining(", ", "(", ")"));
}
diff --git a/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java b/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java
index cf928d5..30ad092 100644
--- a/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java
+++ b/value/src/main/java/com/google/auto/value/processor/GwtSerialization.java
@@ -18,6 +18,7 @@
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.stream.Collectors.toList;
+import com.google.auto.value.processor.AutoValueishProcessor.GetterProperty;
import com.google.auto.value.processor.PropertyBuilderClassifier.PropertyBuilder;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Multimap;
@@ -80,12 +81,14 @@
* com.example.AutoValue_Foo_CustomFieldSerializer.
*
* @param autoVars the template variables defined for this type.
+ * @param finalSubclass the simple name of the AutoValue class being generated, AutoValue_Foo
+ * in the example.
*/
- void maybeWriteGwtSerializer(AutoValueTemplateVars autoVars) {
+ void maybeWriteGwtSerializer(AutoValueTemplateVars autoVars, String finalSubclass) {
if (shouldWriteGwtSerializer()) {
GwtTemplateVars vars = new GwtTemplateVars();
vars.pkg = autoVars.pkg;
- vars.subclass = autoVars.finalSubclass;
+ vars.subclass = finalSubclass;
vars.formalTypes = autoVars.formalTypes;
vars.actualTypes = autoVars.actualTypes;
vars.useBuilder = !autoVars.builderTypeName.isEmpty();
@@ -95,7 +98,8 @@
String className =
(vars.pkg.isEmpty() ? "" : vars.pkg + ".") + vars.subclass + "_CustomFieldSerializer";
vars.serializerClass = TypeSimplifier.simpleNameOf(className);
- vars.props = autoVars.props.stream().map(Property::new).collect(toList());
+ vars.props =
+ autoVars.props.stream().map(p -> new Property((GetterProperty) p)).collect(toList());
vars.classHashString = computeClassHash(autoVars.props, vars.pkg);
String text = vars.toText();
text = TypeEncoder.decode(text, processingEnv, vars.pkg, type.asType());
@@ -104,10 +108,10 @@
}
public static class Property {
- private final AutoValueProcessor.Property property;
+ private final GetterProperty property;
private final boolean isCastingUnchecked;
- Property(AutoValueProcessor.Property property) {
+ Property(GetterProperty property) {
this.property = property;
this.isCastingUnchecked = TypeSimplifier.isCastingUnchecked(property.getTypeMirror());
}
@@ -242,14 +246,14 @@
.printMessage(
Diagnostic.Kind.WARNING, "Could not write generated class " + className + ": " + e);
// A warning rather than an error for the reason explained in
- // AutoValueOrOneOfProcessor.writeSourceFile.
+ // AutoValueishProcessor.writeSourceFile.
}
}
// Compute a hash that is guaranteed to change if the names, types, or order of the fields
// change. We use TypeEncoder so that we can get a defined string for types, since
// TypeMirror.toString() isn't guaranteed to remain the same.
- private String computeClassHash(Iterable<AutoValueProcessor.Property> props, String pkg) {
+ private String computeClassHash(Iterable<AutoValueishProcessor.Property> props, String pkg) {
CRC32 crc = new CRC32();
String encodedType = TypeEncoder.encode(type.asType()) + ":";
String decodedType = TypeEncoder.decode(encodedType, processingEnv, "", null);
@@ -259,7 +263,7 @@
decodedType = pkg + "." + decodedType;
}
crc.update(decodedType.getBytes(UTF_8));
- for (AutoValueProcessor.Property prop : props) {
+ for (AutoValueishProcessor.Property prop : props) {
String encodedProp = prop + ":" + TypeEncoder.encode(prop.getTypeMirror()) + ";";
String decodedProp = TypeEncoder.decode(encodedProp, processingEnv, pkg, null);
crc.update(decodedProp.getBytes(UTF_8));
diff --git a/value/src/main/java/com/google/auto/value/processor/Nullables.java b/value/src/main/java/com/google/auto/value/processor/Nullables.java
new file mode 100644
index 0000000..c07656f
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/Nullables.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import static java.util.stream.Collectors.toList;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+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.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.IntersectionType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.type.WildcardType;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+class Nullables {
+ /**
+ * If set to a non-empty string, defines which {@code @Nullable} type annotation should be used by
+ * default. If set to an empty string, does not insert {@code @Nullable} unless it is referenced
+ * in the {@code @AutoValue} methods. If unset, defaults to {@value #DEFAULT_NULLABLE}.
+ */
+ static final String NULLABLE_OPTION = "com.google.auto.value.NullableTypeAnnotation";
+
+ // We write this using .concat in order to hide it from rewriting rules.
+ private static final String DEFAULT_NULLABLE = "org".concat(".jspecify.nullness.Nullable");
+
+ private final Optional<AnnotationMirror> defaultNullable;
+
+ Nullables(ProcessingEnvironment processingEnv) {
+ // -Afoo without `=` sets "foo" to null in the getOptions() map.
+ String nullableOption =
+ Strings.nullToEmpty(
+ processingEnv.getOptions().getOrDefault(NULLABLE_OPTION, DEFAULT_NULLABLE));
+ this.defaultNullable =
+ (!nullableOption.isEmpty()
+ && processingEnv.getSourceVersion().ordinal() >= SourceVersion.RELEASE_8.ordinal())
+ ? Optional.ofNullable(processingEnv.getElementUtils().getTypeElement(nullableOption))
+ .map(t -> annotationMirrorOf(MoreTypes.asDeclared(t.asType())))
+ : Optional.empty();
+ }
+
+ private static AnnotationMirror annotationMirrorOf(DeclaredType annotationType) {
+ return new AnnotationMirror() {
+ @Override
+ public DeclaredType getAnnotationType() {
+ return annotationType;
+ }
+
+ @Override
+ public ImmutableMap<? extends ExecutableElement, ? extends AnnotationValue>
+ getElementValues() {
+ return ImmutableMap.of();
+ }
+ };
+ }
+
+ /**
+ * Returns the type of a {@code @Nullable} type-annotation, if one is found anywhere in the
+ * signatures of the given methods.
+ */
+ @VisibleForTesting
+ static Optional<AnnotationMirror> nullableMentionedInMethods(
+ Collection<ExecutableElement> methods) {
+ return methods.stream()
+ .flatMap(
+ method ->
+ Stream.concat(
+ Stream.of(method.getReturnType()),
+ method.getParameters().stream().map(Element::asType)))
+ .map(Nullables::nullableIn)
+ .filter(Optional::isPresent)
+ .findFirst()
+ .orElse(Optional.empty());
+ }
+
+ /**
+ * Returns the type of an appropriate {@code @Nullable} type-annotation, given a set of methods
+ * that are known to be in the same compilation as the code being generated. If one of those
+ * methods contains an appropriate {@code @Nullable} annotation on a parameter or return type,
+ * this method will return that. Otherwise, if the <a href="http://jspecify.org">JSpecify</a>
+ * {@code @Nullable} is available, this method will return it. Otherwise, this method will return
+ * an empty {@code Optional}.
+ */
+ Optional<AnnotationMirror> appropriateNullableGivenMethods(
+ Collection<ExecutableElement> methods) {
+ return nullableMentionedInMethods(methods).map(Optional::of).orElse(defaultNullable);
+ }
+
+ private static Optional<AnnotationMirror> nullableIn(TypeMirror type) {
+ return new NullableFinder().visit(type);
+ }
+
+ private static Optional<AnnotationMirror> nullableIn(
+ List<? extends AnnotationMirror> annotations) {
+ return annotations.stream()
+ .filter(a -> a.getAnnotationType().asElement().getSimpleName().contentEquals("Nullable"))
+ .map(a -> (AnnotationMirror) a) // get rid of the pesky wildcard
+ .findFirst();
+ }
+
+ private static class NullableFinder extends SimpleTypeVisitor8<Optional<AnnotationMirror>, Void> {
+ private final TypeMirrorSet visiting = new TypeMirrorSet();
+
+ NullableFinder() {
+ super(Optional.empty());
+ }
+
+ // Primitives can't be @Nullable so we don't check that.
+
+ @Override
+ public Optional<AnnotationMirror> visitDeclared(DeclaredType t, Void unused) {
+ if (!visiting.add(t)) {
+ return Optional.empty();
+ }
+ return nullableIn(t.getAnnotationMirrors())
+ .map(Optional::of)
+ .orElseGet(() -> visitAll(t.getTypeArguments()));
+ }
+
+ @Override
+ public Optional<AnnotationMirror> visitTypeVariable(TypeVariable t, Void unused) {
+ if (!visiting.add(t)) {
+ return Optional.empty();
+ }
+ return nullableIn(t.getAnnotationMirrors())
+ .map(Optional::of)
+ .orElseGet(() -> visitAll(ImmutableList.of(t.getUpperBound(), t.getLowerBound())));
+ }
+
+ @Override
+ public Optional<AnnotationMirror> visitArray(ArrayType t, Void unused) {
+ return nullableIn(t.getAnnotationMirrors())
+ .map(Optional::of)
+ .orElseGet(() -> visit(t.getComponentType()));
+ }
+
+ @Override
+ public Optional<AnnotationMirror> visitWildcard(WildcardType t, Void unused) {
+ return nullableIn(t.getAnnotationMirrors())
+ .map(Optional::of)
+ .orElseGet(
+ () ->
+ visitAll(
+ Stream.of(t.getExtendsBound(), t.getSuperBound())
+ .filter(Objects::nonNull)
+ .collect(toList())));
+ }
+
+ @Override
+ public Optional<AnnotationMirror> visitIntersection(IntersectionType t, Void unused) {
+ return nullableIn(t.getAnnotationMirrors())
+ .map(Optional::of)
+ .orElseGet(() -> visitAll(t.getBounds()));
+ }
+
+ private Optional<AnnotationMirror> visitAll(List<? extends TypeMirror> types) {
+ return types.stream()
+ .map(this::visit)
+ .filter(Optional::isPresent)
+ .findFirst()
+ .orElse(Optional.empty());
+ }
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/PropertyBuilderClassifier.java b/value/src/main/java/com/google/auto/value/processor/PropertyBuilderClassifier.java
index 2565cdd..5d0168e 100644
--- a/value/src/main/java/com/google/auto/value/processor/PropertyBuilderClassifier.java
+++ b/value/src/main/java/com/google/auto/value/processor/PropertyBuilderClassifier.java
@@ -15,17 +15,19 @@
*/
package com.google.auto.value.processor;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toMap;
+
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import java.util.LinkedHashMap;
-import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
+import java.util.function.Function;
+import java.util.function.Predicate;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
@@ -51,25 +53,25 @@
private final ErrorReporter errorReporter;
private final Types typeUtils;
private final Elements elementUtils;
- private final BuilderMethodClassifier builderMethodClassifier;
- private final ImmutableBiMap<ExecutableElement, String> getterToPropertyName;
- private final ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType;
+ private final BuilderMethodClassifier<?> builderMethodClassifier;
+ private final Predicate<String> propertyIsNullable;
+ private final ImmutableMap<String, TypeMirror> propertyTypes;
private final EclipseHack eclipseHack;
PropertyBuilderClassifier(
ErrorReporter errorReporter,
Types typeUtils,
Elements elementUtils,
- BuilderMethodClassifier builderMethodClassifier,
- ImmutableBiMap<ExecutableElement, String> getterToPropertyName,
- ImmutableMap<ExecutableElement, TypeMirror> getterToPropertyType,
+ BuilderMethodClassifier<?> builderMethodClassifier,
+ Predicate<String> propertyIsNullable,
+ ImmutableMap<String, TypeMirror> propertyTypes,
EclipseHack eclipseHack) {
this.errorReporter = errorReporter;
this.typeUtils = typeUtils;
this.elementUtils = elementUtils;
this.builderMethodClassifier = builderMethodClassifier;
- this.getterToPropertyName = getterToPropertyName;
- this.getterToPropertyType = getterToPropertyType;
+ this.propertyIsNullable = propertyIsNullable;
+ this.propertyTypes = propertyTypes;
this.eclipseHack = eclipseHack;
}
@@ -115,6 +117,14 @@
return propertyBuilderMethod;
}
+ /** The property builder method parameters, for example {@code Comparator<T> comparator} */
+ public String getPropertyBuilderMethodParameters() {
+ return propertyBuilderMethod.getParameters().stream()
+ .map(
+ parameter -> TypeEncoder.encode(parameter.asType()) + " " + parameter.getSimpleName())
+ .collect(joining(", "));
+ }
+
public String getAccess() {
return SimpleMethod.access(propertyBuilderMethod);
}
@@ -206,8 +216,7 @@
TypeElement barBuilderTypeElement = MoreTypes.asTypeElement(barBuilderTypeMirror);
Map<String, ExecutableElement> barBuilderNoArgMethods = noArgMethodsOf(barBuilderTypeElement);
- ExecutableElement barGetter = getterToPropertyName.inverse().get(property);
- TypeMirror barTypeMirror = getterToPropertyType.get(barGetter);
+ TypeMirror barTypeMirror = propertyTypes.get(property);
if (barTypeMirror.getKind() != TypeKind.DECLARED) {
errorReporter.reportError(
method,
@@ -216,10 +225,10 @@
property);
return Optional.empty();
}
- if (isNullable(barGetter)) {
+ if (propertyIsNullable.test(property)) {
errorReporter.reportError(
- barGetter,
- "[AutoValueNullBuilder] Property %s has a property builder so it cannot be @Nullable",
+ method,
+ "[AutoValueNullBuilder] Property %s is @Nullable so it cannot have a property builder",
property);
}
TypeElement barTypeElement = MoreTypes.asTypeElement(barTypeMirror);
@@ -251,8 +260,13 @@
return Optional.empty();
}
- Optional<ExecutableElement> maybeBuilderMaker =
- builderMaker(barNoArgMethods, barBuilderTypeElement);
+ Optional<ExecutableElement> maybeBuilderMaker;
+ if (method.getParameters().isEmpty()) {
+ maybeBuilderMaker = noArgBuilderMaker(barNoArgMethods, barBuilderTypeElement);
+ } else {
+ Map<String, ExecutableElement> barOneArgMethods = oneArgumentMethodsOf(barTypeElement);
+ maybeBuilderMaker = oneArgBuilderMaker(barOneArgMethods, barBuilderTypeElement);
+ }
if (!maybeBuilderMaker.isPresent()) {
errorReporter.reportError(
method,
@@ -268,10 +282,14 @@
String barBuilderType = TypeEncoder.encodeWithAnnotations(barBuilderTypeMirror);
String rawBarType = TypeEncoder.encodeRaw(barTypeMirror);
+ String arguments =
+ method.getParameters().isEmpty()
+ ? "()"
+ : "(" + method.getParameters().get(0).getSimpleName() + ")";
String initializer =
(builderMaker.getKind() == ElementKind.CONSTRUCTOR)
- ? "new " + barBuilderType + "()"
- : rawBarType + "." + builderMaker.getSimpleName() + "()";
+ ? "new " + barBuilderType + arguments
+ : rawBarType + "." + builderMaker.getSimpleName() + arguments;
String builtToBuilder = null;
String copyAll = null;
ExecutableElement toBuilder = barNoArgMethods.get("toBuilder");
@@ -324,41 +342,75 @@
private static final ImmutableSet<String> BUILDER_METHOD_NAMES =
ImmutableSet.of("naturalOrder", "builder", "newBuilder");
- // (2) `BarBuilder must have a public no-arg constructor, or `Bar` must have a visible static
- // method `naturalOrder(), `builder()`, or `newBuilder()` that returns `BarBuilder`.
- private Optional<ExecutableElement> builderMaker(
+ // (2) `BarBuilder` must have a public no-arg constructor, or `Bar` must have a visible static
+ // method `naturalOrder(), `builder()`, or `newBuilder()` that returns `BarBuilder`; or,
+ // if we have a foosBuilder(T) method, then `BarBuilder` must have a public constructor with
+ // a single parameter assignable from T, or a visible static `builder(T)` method.
+ private Optional<ExecutableElement> noArgBuilderMaker(
Map<String, ExecutableElement> barNoArgMethods, TypeElement barBuilderTypeElement) {
- for (String builderMethodName : BUILDER_METHOD_NAMES) {
- ExecutableElement method = barNoArgMethods.get(builderMethodName);
- if (method != null
- && method.getModifiers().contains(Modifier.STATIC)
- && typeUtils.isSameType(
- typeUtils.erasure(method.getReturnType()),
- typeUtils.erasure(barBuilderTypeElement.asType()))) {
- // TODO(emcmanus): check visibility. We don't want to require public for @AutoValue
- // builders. By not checking visibility we risk accepting something as a builder maker
- // and then failing when the generated code tries to call Bar.builder(). But the risk
- // seems small.
- return Optional.of(method);
- }
+ return builderMaker(BUILDER_METHOD_NAMES, barNoArgMethods, barBuilderTypeElement, 0);
+ }
+
+ private static final ImmutableSet<String> ONE_ARGUMENT_BUILDER_METHOD_NAMES =
+ ImmutableSet.of("builder");
+
+ private Optional<ExecutableElement> oneArgBuilderMaker(
+ Map<String, ExecutableElement> barOneArgMethods, TypeElement barBuilderTypeElement) {
+
+ return builderMaker(
+ ONE_ARGUMENT_BUILDER_METHOD_NAMES, barOneArgMethods, barBuilderTypeElement, 1);
+ }
+
+ private Optional<ExecutableElement> builderMaker(
+ ImmutableSet<String> methodNamesToCheck,
+ Map<String, ExecutableElement> methods,
+ TypeElement barBuilderTypeElement,
+ int argumentCount) {
+ Optional<ExecutableElement> maybeMethod =
+ methodNamesToCheck.stream()
+ .map(methods::get)
+ .filter(Objects::nonNull)
+ .filter(method -> method.getModifiers().contains(Modifier.STATIC))
+ .filter(
+ method ->
+ typeUtils.isSameType(
+ typeUtils.erasure(method.getReturnType()),
+ typeUtils.erasure(barBuilderTypeElement.asType())))
+ .findFirst();
+
+ if (maybeMethod.isPresent()) {
+ // TODO(emcmanus): check visibility. We don't want to require public for @AutoValue
+ // builders. By not checking visibility we risk accepting something as a builder maker
+ // and then failing when the generated code tries to call Bar.builder(). But the risk
+ // seems small.
+ return maybeMethod;
}
- return ElementFilter.constructorsIn(barBuilderTypeElement.getEnclosedElements())
- .stream()
- .filter(c -> c.getParameters().isEmpty())
+
+ return ElementFilter.constructorsIn(barBuilderTypeElement.getEnclosedElements()).stream()
+ .filter(c -> c.getParameters().size() == argumentCount)
.filter(c -> c.getModifiers().contains(Modifier.PUBLIC))
.findFirst();
}
private Map<String, ExecutableElement> noArgMethodsOf(TypeElement type) {
- // Can't easily use ImmutableMap here because getAllMembers could return more than one method
- // with the same name.
- Map<String, ExecutableElement> methods = new LinkedHashMap<>();
- for (ExecutableElement method : ElementFilter.methodsIn(elementUtils.getAllMembers(type))) {
- if (method.getParameters().isEmpty() && !isStaticInterfaceMethodNotIn(method, type)) {
- methods.put(method.getSimpleName().toString(), method);
- }
- }
- return methods;
+ return methodsOf(type, 0);
+ }
+
+ private ImmutableMap<String, ExecutableElement> oneArgumentMethodsOf(TypeElement type) {
+ return methodsOf(type, 1);
+ }
+
+ private ImmutableMap<String, ExecutableElement> methodsOf(TypeElement type, int argumentCount) {
+ return ElementFilter.methodsIn(elementUtils.getAllMembers(type)).stream()
+ .filter(method -> method.getParameters().size() == argumentCount)
+ .filter(method -> !isStaticInterfaceMethodNotIn(method, type))
+ .collect(
+ collectingAndThen(
+ toMap(
+ method -> method.getSimpleName().toString(),
+ Function.identity(),
+ (method1, method2) -> method1),
+ ImmutableMap::copyOf));
}
// Work around an Eclipse compiler bug: https://bugs.eclipse.org/bugs/show_bug.cgi?id=547185
@@ -399,18 +451,4 @@
})
.findFirst();
}
-
- private static boolean isNullable(ExecutableElement getter) {
- List<List<? extends AnnotationMirror>> annotationLists =
- ImmutableList.of(
- getter.getAnnotationMirrors(), getter.getReturnType().getAnnotationMirrors());
- for (List<? extends AnnotationMirror> annotations : annotationLists) {
- for (AnnotationMirror annotation : annotations) {
- if (annotation.getAnnotationType().asElement().getSimpleName().contentEquals("Nullable")) {
- return true;
- }
- }
- }
- return false;
- }
}
diff --git a/value/src/main/java/com/google/auto/value/processor/Reformatter.java b/value/src/main/java/com/google/auto/value/processor/Reformatter.java
index 6926517..89b6d0d 100644
--- a/value/src/main/java/com/google/auto/value/processor/Reformatter.java
+++ b/value/src/main/java/com/google/auto/value/processor/Reformatter.java
@@ -15,6 +15,8 @@
*/
package com.google.auto.value.processor;
+import com.google.common.base.CharMatcher;
+
/**
* Postprocessor that runs over the output of the template engine in order to make it look nicer.
* Mostly, this involves removing surplus horizontal and vertical space.
@@ -22,6 +24,14 @@
* @author emcmanus@google.com (Éamonn McManus)
*/
class Reformatter {
+ /**
+ * Characters that might start a continuation line. Since Google Style requires splitting before
+ * operators, we expect that a continuation line will begin with one of these (or be inside
+ * parentheses). We've omitted {@code /} from this list for now since none of our templates splits
+ * before one, and otherwise we'd have to handle {@code //} and {@code /*}.
+ */
+ private static final CharMatcher OPERATORS = CharMatcher.anyOf("+-*%&|^<>=?:.").precomputed();
+
static String fixup(String s) {
StringBuilder out = new StringBuilder();
JavaScanner scanner = new JavaScanner(s);
@@ -49,27 +59,43 @@
case ' ':
// This token is a string of consecutive spaces that is not at the start of a line.
// Consecutive spaces at the start of a line are attached to the previous newline, and
- // we don't expect the first line to start with spaces. So we are going to compress this
+ // we delete spaces at the start of the first line. So we are going to compress this
// into just one space, and we are going to delete it entirely if it follows '(' or
// precedes a newline or one of the punctuation characters here.
- if (s.charAt(previous) != '(' && "\n.,;)".indexOf(s.charAt(end)) < 0) {
+ if (start > 0 && s.charAt(previous) != '(' && "\n.,;)".indexOf(s.charAt(end)) < 0) {
out.append(' ');
}
continue;
case '\n':
// This token is a newline plus any following spaces (the indentation of the next line).
- // If it is followed by something other than a newline then we will output it. Otherwise,
- // it is part of a sequence of newlines but it is not the last one. If this is a context
- // where we delete blank lines, or if this is not the first new line in the sequence, or
- // if we are at the start of the file, we will delete this one. Otherwise we will output a
- // single newline with no following indentation. Contexts where we delete blank lines are
- // inside parentheses or inside more than one set of braces.
+ // If it is followed by something other than a newline then we will output the
+ // newline, and replace the following spaces by our computed indentation. Otherwise, the
+ // token is part of a sequence of newlines but it is not the last one. If this is a
+ // context where we delete blank lines, or if this is not the first new line in the
+ // sequence, or if we are at the start of the file, we will delete this one. Otherwise we
+ // will output a single newline with no following indentation. Contexts where we delete
+ // blank lines are inside parentheses or inside more than one set of braces.
if (end < len && s.charAt(end) != '\n') {
- if (out.length() == 0) {
- // Omit newlines at the very start of the file.
- start++;
+ // Omit newlines at the very start of the file. Also delete newline+indent between
+ // ( and ), since that shows up in some places where we output one parameter per line,
+ // when there are no parameters.
+ char prev = s.charAt(previous);
+ char next = s.charAt(end);
+ if (out.length() > 0 && (prev != '(' || next != ')')) {
+ out.append('\n');
+ // Replace any space after the newline with our computed indentation. The algorithm
+ // here is simplistic but works OK for our current templates.
+ int indent = braces * 2;
+ if (parens > 0 || OPERATORS.matches(next)) {
+ indent += 4;
+ } else if (next == '}') {
+ indent -= 2;
+ }
+ for (int i = 0; i < indent; i++) {
+ out.append(' ');
+ }
}
- break; // Output the newline and its following indentation.
+ continue;
}
if (parens == 0 && braces < 2 && s.charAt(previous) != '\n' && out.length() > 0) {
out.append('\n');
@@ -82,4 +108,6 @@
}
return out.toString();
}
+
+ private Reformatter() {}
}
diff --git a/value/src/main/java/com/google/auto/value/processor/SimpleMethod.java b/value/src/main/java/com/google/auto/value/processor/SimpleMethod.java
index 0351023..c144bc0 100644
--- a/value/src/main/java/com/google/auto/value/processor/SimpleMethod.java
+++ b/value/src/main/java/com/google/auto/value/processor/SimpleMethod.java
@@ -15,6 +15,8 @@
*/
package com.google.auto.value.processor;
+import static java.util.stream.Collectors.joining;
+
import java.util.Set;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
@@ -31,10 +33,12 @@
public final class SimpleMethod {
private final String access;
private final String name;
+ private final String throwsString;
SimpleMethod(ExecutableElement method) {
this.access = access(method);
this.name = method.getSimpleName().toString();
+ this.throwsString = throwsString(method);
}
public String getAccess() {
@@ -45,6 +49,10 @@
return name;
}
+ public String getThrows() {
+ return throwsString;
+ }
+
/**
* Returns an appropriate string to be used in code for the access specification of the given
* method. This will be {@code public} or {@code protected} followed by a space, or the empty
@@ -60,4 +68,12 @@
return "";
}
}
+
+ private static String throwsString(ExecutableElement method) {
+ if (method.getThrownTypes().isEmpty()) {
+ return "";
+ }
+ return "throws "
+ + method.getThrownTypes().stream().map(TypeEncoder::encode).collect(joining(", "));
+ }
}
diff --git a/value/src/main/java/com/google/auto/value/processor/SimpleServiceLoader.java b/value/src/main/java/com/google/auto/value/processor/SimpleServiceLoader.java
index 55f9ae4..23f6674 100644
--- a/value/src/main/java/com/google/auto/value/processor/SimpleServiceLoader.java
+++ b/value/src/main/java/com/google/auto/value/processor/SimpleServiceLoader.java
@@ -15,20 +15,23 @@
*/
package com.google.auto.value.processor;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.stream.Collectors.toList;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Streams;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
-import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.ServiceConfigurationError;
+import java.util.regex.Pattern;
/**
* A replacement for {@link java.util.ServiceLoader} that avoids certain long-standing bugs. This
@@ -43,6 +46,11 @@
private SimpleServiceLoader() {}
public static <T> ImmutableList<T> load(Class<? extends T> service, ClassLoader loader) {
+ return load(service, loader, Optional.empty());
+ }
+
+ public static <T> ImmutableList<T> load(
+ Class<? extends T> service, ClassLoader loader, Optional<Pattern> allowedMissingClasses) {
String resourceName = "META-INF/services/" + service.getName();
List<URL> resourceUrls;
try {
@@ -50,49 +58,64 @@
} catch (IOException e) {
throw new ServiceConfigurationError("Could not look up " + resourceName, e);
}
- ImmutableList.Builder<T> providers = ImmutableList.builder();
+ ImmutableSet.Builder<Class<? extends T>> providerClasses = ImmutableSet.builder();
for (URL resourceUrl : resourceUrls) {
try {
- providers.addAll(providersFromUrl(resourceUrl, service, loader));
+ providerClasses.addAll(
+ providerClassesFromUrl(resourceUrl, service, loader, allowedMissingClasses));
} catch (IOException e) {
throw new ServiceConfigurationError("Could not read " + resourceUrl, e);
}
}
+ ImmutableList.Builder<T> providers = ImmutableList.builder();
+ for (Class<? extends T> providerClass : providerClasses.build()) {
+ try {
+ T provider = providerClass.getConstructor().newInstance();
+ providers.add(provider);
+ } catch (ReflectiveOperationException e) {
+ throw new ServiceConfigurationError("Could not construct " + providerClass.getName(), e);
+ }
+ }
return providers.build();
}
- private static <T> ImmutableList<T> providersFromUrl(
- URL resourceUrl, Class<T> service, ClassLoader loader) throws IOException {
- ImmutableList.Builder<T> providers = ImmutableList.builder();
+ private static <T> ImmutableSet<Class<? extends T>> providerClassesFromUrl(
+ URL resourceUrl,
+ Class<? extends T> service,
+ ClassLoader loader,
+ Optional<Pattern> allowedMissingClasses)
+ throws IOException {
+ ImmutableSet.Builder<Class<? extends T>> providerClasses = ImmutableSet.builder();
URLConnection urlConnection = resourceUrl.openConnection();
urlConnection.setUseCaches(false);
+ List<String> lines;
try (InputStream in = urlConnection.getInputStream();
- BufferedReader reader =
- new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
- for (String line : reader.lines().collect(toList())) {
- Optional<String> maybeClassName = parseClassName(line);
- if (maybeClassName.isPresent()) {
- String className = maybeClassName.get();
- Class<?> c;
- try {
- c = Class.forName(className, false, loader);
- } catch (ClassNotFoundException e) {
- throw new ServiceConfigurationError("Could not load " + className, e);
- }
- if (!service.isAssignableFrom(c)) {
- throw new ServiceConfigurationError(
- "Class " + className + " is not assignable to " + service.getName());
- }
- try {
- Object provider = c.getConstructor().newInstance();
- providers.add(service.cast(provider));
- } catch (ReflectiveOperationException e) {
- throw new ServiceConfigurationError("Could not construct " + className, e);
- }
- }
- }
- return providers.build();
+ BufferedReader reader = new BufferedReader(new InputStreamReader(in, UTF_8))) {
+ lines = reader.lines().collect(toList());
}
+ List<String> classNames =
+ lines.stream()
+ .map(SimpleServiceLoader::parseClassName)
+ .flatMap(Streams::stream)
+ .collect(toList());
+ for (String className : classNames) {
+ Class<?> c;
+ try {
+ c = Class.forName(className, false, loader);
+ } catch (ClassNotFoundException e) {
+ if (allowedMissingClasses.isPresent()
+ && allowedMissingClasses.get().matcher(className).matches()) {
+ continue;
+ }
+ throw new ServiceConfigurationError("Could not load " + className, e);
+ }
+ if (!service.isAssignableFrom(c)) {
+ throw new ServiceConfigurationError(
+ "Class " + className + " is not assignable to " + service.getName());
+ }
+ providerClasses.add(c.asSubclass(service));
+ }
+ return providerClasses.build();
}
private static Optional<String> parseClassName(String line) {
diff --git a/value/src/main/java/com/google/auto/value/processor/TemplateVars.java b/value/src/main/java/com/google/auto/value/processor/TemplateVars.java
index 235f0ad..d9e3337 100644
--- a/value/src/main/java/com/google/auto/value/processor/TemplateVars.java
+++ b/value/src/main/java/com/google/auto/value/processor/TemplateVars.java
@@ -99,7 +99,7 @@
return parsedTemplate().evaluate(vars);
}
- private Map<String, Object> toVars() {
+ private ImmutableMap<String, Object> toVars() {
Map<String, Object> vars = new TreeMap<>();
for (Field field : fields) {
Object value = fieldValue(field, this);
@@ -114,6 +114,11 @@
return ImmutableMap.copyOf(vars);
}
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + toVars();
+ }
+
static Template parsedTemplateForResource(String resourceName) {
try {
return Template.parseFrom(resourceName, TemplateVars::readerFromResource);
diff --git a/value/src/main/java/com/google/auto/value/processor/TypeEncoder.java b/value/src/main/java/com/google/auto/value/processor/TypeEncoder.java
index d1bbbab..81968a5 100644
--- a/value/src/main/java/com/google/auto/value/processor/TypeEncoder.java
+++ b/value/src/main/java/com/google/auto/value/processor/TypeEncoder.java
@@ -22,10 +22,12 @@
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.auto.value.processor.MissingTypes.MissingTypeException;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.List;
import java.util.OptionalInt;
import java.util.Set;
+import java.util.function.Function;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.TypeElement;
@@ -97,20 +99,36 @@
* covers the details of annotation encoding.
*/
static String encodeWithAnnotations(TypeMirror type) {
- return encodeWithAnnotations(type, ImmutableSet.of());
+ return encodeWithAnnotations(type, ImmutableList.of(), ImmutableSet.of());
}
/**
* Encodes the given type and its type annotations. The class comment for {@link TypeEncoder}
* covers the details of annotation encoding.
*
+ * @param extraAnnotations additional type annotations to include with the type
* @param excludedAnnotationTypes annotations not to include in the encoding. For example, if
* {@code com.example.Nullable} is in this set then the encoding will not include this
* {@code @Nullable} annotation.
*/
- static String encodeWithAnnotations(TypeMirror type, Set<TypeMirror> excludedAnnotationTypes) {
+ static String encodeWithAnnotations(
+ TypeMirror type,
+ ImmutableList<AnnotationMirror> extraAnnotations,
+ Set<TypeMirror> excludedAnnotationTypes) {
StringBuilder sb = new StringBuilder();
- return new AnnotatedEncodingTypeVisitor(excludedAnnotationTypes).visit2(type, sb).toString();
+ // A function that is equivalent to t.getAnnotationMirrors() except when the t in question is
+ // our starting type. In that case we also add extraAnnotations to the result.
+ Function<TypeMirror, List<? extends AnnotationMirror>> getTypeAnnotations =
+ t ->
+ (t == type)
+ ? ImmutableList.<AnnotationMirror>builder()
+ .addAll(t.getAnnotationMirrors())
+ .addAll(extraAnnotations)
+ .build()
+ : t.getAnnotationMirrors();
+ return new AnnotatedEncodingTypeVisitor(excludedAnnotationTypes, getTypeAnnotations)
+ .visit2(type, sb)
+ .toString();
}
/**
@@ -145,9 +163,11 @@
}
/**
- * Returns the formal type parameters of the given type. If we have {@code @AutoValue abstract
- * class Foo<T extends SomeClass>} then this method will return an encoding of {@code <T extends
- * SomeClass>} for {@code Foo}. Likewise it will return an encoding of the angle-bracket part of:
+ * Returns a string representing the given type parameters as they would appear in a class
+ * declaration. For example, if we have {@code @AutoValue abstract
+ * class Foo<T extends SomeClass>} then if we call {@link TypeElement#getTypeParameters()} on
+ * the representation of {@code Foo}, this method will return an encoding of {@code <T extends
+ * SomeClass>}. Likewise it will return an encoding of the angle-bracket part of:
* <br>
* {@code Foo<SomeClass>}<br>
* {@code Foo<T extends Number>}<br>
@@ -161,8 +181,7 @@
* {@code <E extends `java.lang.Enum`<E>>}<br>
* {@code <K, V extends `java.lang.Comparable`<? extends K>>}.
*/
- static String formalTypeParametersString(TypeElement type) {
- List<? extends TypeParameterElement> typeParameters = type.getTypeParameters();
+ static String typeParametersString(List<? extends TypeParameterElement> typeParameters) {
if (typeParameters.isEmpty()) {
return "";
} else {
@@ -308,9 +327,13 @@
*/
private static class AnnotatedEncodingTypeVisitor extends EncodingTypeVisitor {
private final Set<TypeMirror> excludedAnnotationTypes;
+ private final Function<TypeMirror, List<? extends AnnotationMirror>> getTypeAnnotations;
- AnnotatedEncodingTypeVisitor(Set<TypeMirror> excludedAnnotationTypes) {
+ AnnotatedEncodingTypeVisitor(
+ Set<TypeMirror> excludedAnnotationTypes,
+ Function<TypeMirror, List<? extends AnnotationMirror>> getTypeAnnotations) {
this.excludedAnnotationTypes = excludedAnnotationTypes;
+ this.getTypeAnnotations = getTypeAnnotations;
}
private void appendAnnotationsWithExclusions(
@@ -330,7 +353,7 @@
@Override
public StringBuilder visitPrimitive(PrimitiveType type, StringBuilder sb) {
- appendAnnotationsWithExclusions(type.getAnnotationMirrors(), sb);
+ appendAnnotationsWithExclusions(getTypeAnnotations.apply(type), sb);
// We can't just append type.toString(), because that will also have the annotation, but
// without encoding.
return sb.append(type.getKind().toString().toLowerCase());
@@ -338,7 +361,7 @@
@Override
public StringBuilder visitTypeVariable(TypeVariable type, StringBuilder sb) {
- appendAnnotationsWithExclusions(type.getAnnotationMirrors(), sb);
+ appendAnnotationsWithExclusions(getTypeAnnotations.apply(type), sb);
return sb.append(type.asElement().getSimpleName());
}
@@ -350,7 +373,7 @@
@Override
public StringBuilder visitArray(ArrayType type, StringBuilder sb) {
visit2(type.getComponentType(), sb);
- List<? extends AnnotationMirror> annotationMirrors = type.getAnnotationMirrors();
+ List<? extends AnnotationMirror> annotationMirrors = getTypeAnnotations.apply(type);
if (!annotationMirrors.isEmpty()) {
sb.append(" ");
appendAnnotationsWithExclusions(annotationMirrors, sb);
@@ -360,7 +383,7 @@
@Override
public StringBuilder visitDeclared(DeclaredType type, StringBuilder sb) {
- List<? extends AnnotationMirror> annotationMirrors = type.getAnnotationMirrors();
+ List<? extends AnnotationMirror> annotationMirrors = getTypeAnnotations.apply(type);
if (annotationMirrors.isEmpty()) {
super.visitDeclared(type, sb);
} else {
diff --git a/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java b/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java
index 290e59e..e7bab77 100644
--- a/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java
+++ b/value/src/main/java/com/google/auto/value/processor/TypeSimplifier.java
@@ -140,8 +140,7 @@
if (typeParameters.isEmpty()) {
return "";
} else {
- return typeParameters
- .stream()
+ return typeParameters.stream()
.map(e -> e.getSimpleName().toString())
.collect(joining(", ", "<", ">"));
}
@@ -264,8 +263,7 @@
* {@code Map.Entry} everywhere rather than {@code Entry}.
*/
private static Set<TypeMirror> topLevelTypes(Types typeUtil, Set<TypeMirror> types) {
- return types
- .stream()
+ return types.stream()
.map(typeMirror -> MoreElements.asType(typeUtil.asElement(typeMirror)))
.map(typeElement -> topLevelType(typeElement).asType())
.collect(toCollection(TypeMirrorSet::new));
diff --git a/value/src/main/java/com/google/auto/value/processor/TypeVariables.java b/value/src/main/java/com/google/auto/value/processor/TypeVariables.java
index d664ff4..ae27f91 100644
--- a/value/src/main/java/com/google/auto/value/processor/TypeVariables.java
+++ b/value/src/main/java/com/google/auto/value/processor/TypeVariables.java
@@ -15,6 +15,8 @@
*/
package com.google.auto.value.processor;
+import static com.google.auto.common.MoreStreams.toImmutableMap;
+
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.common.base.Equivalence;
@@ -24,6 +26,7 @@
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.function.Function;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
@@ -38,9 +41,7 @@
import javax.lang.model.util.SimpleTypeVisitor8;
import javax.lang.model.util.Types;
-/**
- * Methods for handling type variables.
- */
+/** Methods for handling type variables. */
final class TypeVariables {
private TypeVariables() {}
@@ -60,13 +61,13 @@
* }
* </pre>
*
- * We want to be able to check that the parameter type of {@code setFoo} is the same as the
- * return type of {@code getFoo}. But in fact it isn't, because the {@code T} of {@code Foo<T>}
- * is not the same as the {@code T} of {@code Foo.Builder<T>}. So we create a parallel
- * {@code Foo<T>} where the {@code T} <i>is</i> the one from {@code Foo.Builder<T>}. That way the
- * types do correspond. This method then returns the return types of the given methods as they
- * appear in that parallel class, meaning the type given for {@code getFoo()} is the {@code T} of
- * {@code Foo.Builder<T>}.
+ * We want to be able to check that the parameter type of {@code setFoo} is the same as the return
+ * type of {@code getFoo}. But in fact it isn't, because the {@code T} of {@code Foo<T>} is not
+ * the same as the {@code T} of {@code Foo.Builder<T>}. So we create a parallel {@code Foo<T>}
+ * where the {@code T} <i>is</i> the one from {@code Foo.Builder<T>}. That way the types do
+ * correspond. This method then returns the return types of the given methods as they appear in
+ * that parallel class, meaning the type given for {@code getFoo()} is the {@code T} of {@code
+ * Foo.Builder<T>}.
*
* <p>We do the rewrite this way around (applying the type parameter from {@code Foo.Builder} to
* {@code Foo}) because if we hit one of the historical Eclipse bugs with {@link Types#asMemberOf}
@@ -101,14 +102,12 @@
}
DeclaredType parallelSource = typeUtils.getDeclaredType(sourceType, targetTypeParameterMirrors);
return methods.stream()
- .collect(
- ImmutableMap.toImmutableMap(
- m -> m, m -> eclipseHack.methodReturnType(m, parallelSource)));
+ .collect(toImmutableMap(m -> m, m -> eclipseHack.methodReturnType(m, parallelSource)));
}
/**
- * Tests whether a given parameter can be given to a static method like
- * {@code ImmutableMap.copyOf} to produce a value that can be assigned to the given target type.
+ * Tests whether a given parameter can be given to a static method like {@code
+ * ImmutableMap.copyOf} to produce a value that can be assigned to the given target type.
*
* <p>For example, suppose we have this method in {@code ImmutableMap}:<br>
* {@code static <K, V> ImmutableMap<K, V> copyOf(Map<? extends K, ? extends V>)}<br>
@@ -122,14 +121,14 @@
* We will infer {@code K=String}, {@code V=Number} based on the target type, and then rewrite the
* formal parameter type from<br>
* {@code Map<? extends K, ? extends V>} to<br>
- * {@code Map<? extends String, ? extends Number>}. Then we can check whether
- * {@code actualParameter} is assignable to that.
+ * {@code Map<? extends String, ? extends Number>}. Then we can check whether {@code
+ * actualParameter} is assignable to that.
*
* <p>The logic makes some simplifying assumptions, which are met for the {@code copyOf} and
* {@code of} methods that we use this for. The method must be static, it must have exactly one
* parameter, and it must have type parameters without bounds that are the same as the type
- * parameters of its return type. We can see that these assumptions are met for the
- * {@code ImmutableMap.copyOf} example above.
+ * parameters of its return type. We can see that these assumptions are met for the {@code
+ * ImmutableMap.copyOf} example above.
*/
static boolean canAssignStaticMethodResult(
ExecutableElement method,
@@ -152,8 +151,10 @@
TypeVariable v = MoreTypes.asTypeVariable(typeParameters.get(i).asType());
typeVariables.put(MoreTypes.equivalence().wrap(v), targetTypeArguments.get(i));
}
+ Function<TypeVariable, TypeMirror> substitute =
+ v -> typeVariables.get(MoreTypes.equivalence().wrap(v));
TypeMirror formalParameterType = method.getParameters().get(0).asType();
- SubstitutionVisitor substitutionVisitor = new SubstitutionVisitor(typeVariables, typeUtils);
+ SubstitutionVisitor substitutionVisitor = new SubstitutionVisitor(substitute, typeUtils);
TypeMirror substitutedParameterType = substitutionVisitor.visit(formalParameterType, null);
if (substitutedParameterType.getKind().equals(TypeKind.WILDCARD)) {
// If the target type is Optional<? extends Foo> then <T> T Optional.of(T) will give us
@@ -167,31 +168,38 @@
return typeUtils.isAssignable(actualParameterType, substitutedParameterType);
}
+ static TypeMirror substituteTypeVariables(
+ TypeMirror input, Function<TypeVariable, TypeMirror> substitute, Types typeUtils) {
+ SubstitutionVisitor substitutionVisitor = new SubstitutionVisitor(substitute, typeUtils);
+ return substitutionVisitor.visit(input, null);
+ }
+
/**
* Rewrites types such that references to type variables in the given map are replaced by the
* values of those variables.
*/
private static class SubstitutionVisitor extends SimpleTypeVisitor8<TypeMirror, Void> {
- private final Map<Equivalence.Wrapper<TypeVariable>, TypeMirror> typeVariables;
+ private final Function<TypeVariable, TypeMirror> substitute;
private final Types typeUtils;
- SubstitutionVisitor(
- Map<Equivalence.Wrapper<TypeVariable>, TypeMirror> typeVariables,
- Types typeUtils) {
- this.typeVariables = ImmutableMap.copyOf(typeVariables);
+ SubstitutionVisitor(Function<TypeVariable, TypeMirror> substitute, Types typeUtils) {
+ this.substitute = substitute;
this.typeUtils = typeUtils;
}
- @Override protected TypeMirror defaultAction(TypeMirror t, Void p) {
+ @Override
+ protected TypeMirror defaultAction(TypeMirror t, Void p) {
return t;
}
- @Override public TypeMirror visitTypeVariable(TypeVariable t, Void p) {
- TypeMirror substituted = typeVariables.get(MoreTypes.equivalence().wrap(t));
+ @Override
+ public TypeMirror visitTypeVariable(TypeVariable t, Void p) {
+ TypeMirror substituted = substitute.apply(t);
return (substituted == null) ? t : substituted;
}
- @Override public TypeMirror visitDeclared(DeclaredType t, Void p) {
+ @Override
+ public TypeMirror visitDeclared(DeclaredType t, Void p) {
List<? extends TypeMirror> typeArguments = t.getTypeArguments();
TypeMirror[] substitutedTypeArguments = new TypeMirror[typeArguments.size()];
for (int i = 0; i < typeArguments.size(); i++) {
@@ -201,7 +209,8 @@
MoreElements.asType(t.asElement()), substitutedTypeArguments);
}
- @Override public TypeMirror visitWildcard(WildcardType t, Void p) {
+ @Override
+ public TypeMirror visitWildcard(WildcardType t, Void p) {
TypeMirror ext = visitOrNull(t.getExtendsBound());
if (ext != null && ext.getKind().equals(TypeKind.WILDCARD)) {
// An example of where this happens is if we have this method in ImmutableSet:
@@ -216,7 +225,8 @@
return typeUtils.getWildcardType(ext, visitOrNull(t.getSuperBound()));
}
- @Override public TypeMirror visitArray(ArrayType t, Void p) {
+ @Override
+ public TypeMirror visitArray(ArrayType t, Void p) {
TypeMirror comp = visit(t.getComponentType());
if (comp.getKind().equals(TypeKind.WILDCARD)) {
// An example of where this happens is if we have this method in ImmutableSet:
diff --git a/value/src/main/java/com/google/auto/value/processor/autoannotation.vm b/value/src/main/java/com/google/auto/value/processor/autoannotation.vm
index a953eda..5cdad62 100644
--- a/value/src/main/java/com/google/auto/value/processor/autoannotation.vm
+++ b/value/src/main/java/com/google/auto/value/processor/autoannotation.vm
@@ -45,7 +45,8 @@
#else
// Generated by com.google.auto.value.processor.AutoAnnotationProcessor
#end
-final class $className implements $annotationName {
+final class $className implements $annotationName, `java.io.Serializable` {
+ private static final long serialVersionUID = ${serialVersionUID}L;
## Fields
@@ -212,7 +213,7 @@
#end
@`java.lang.Override`
- public boolean equals(Object o) {
+ public boolean equals($equalsParameterType o) {
if (o == this) {
return true;
}
diff --git a/value/src/main/java/com/google/auto/value/processor/autobuilder.vm b/value/src/main/java/com/google/auto/value/processor/autobuilder.vm
new file mode 100644
index 0000000..01f61b9
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/autobuilder.vm
@@ -0,0 +1,41 @@
+## Copyright 2014 Google LLC
+##
+## 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.
+
+## Template for each generated AutoValue_Foo class.
+## This template uses the Apache Velocity Template Language (VTL).
+## The variables ($pkg, $props, and so on) are defined by the fields of AutoBuilderTemplateVars.
+##
+## Comments, like this one, begin with ##. The comment text extends up to and including the newline
+## character at the end of the line. So comments also serve to join a line to the next one.
+## Velocity deletes a newline after a directive (#if, #foreach, #end etc) so ## is not needed there.
+## That does mean that we sometimes need an extra blank line after such a directive.
+##
+## Post-processing will remove unwanted spaces and blank lines, but will not join two lines.
+## It will also replace classes spelled as (e.g.) `java.util.Arrays`, with the backquotes, to
+## use just Arrays if that class can be imported unambiguously, or java.util.Arrays if not.
+
+#if (!$pkg.empty)
+package $pkg;
+#end
+
+## The following line will be replaced by the required imports during post-processing.
+`import`
+
+#if (!$generated.empty)
+@${generated}("com.google.auto.value.processor.AutoBuilderProcessor")
+#else
+// Generated by com.google.auto.value.processor.AutoBuilderProcessor
+#end
+#set($autoBuilder = true)
+#parse("builder.vm")
diff --git a/value/src/main/java/com/google/auto/value/processor/autooneof.vm b/value/src/main/java/com/google/auto/value/processor/autooneof.vm
index 0249d9e..328f6a5 100644
--- a/value/src/main/java/com/google/auto/value/processor/autooneof.vm
+++ b/value/src/main/java/com/google/auto/value/processor/autooneof.vm
@@ -94,19 +94,23 @@
#end
+#if (!$props.empty)
// Parent class that each implementation will inherit from.
private abstract static class Parent_$formalTypes extends $origClass$actualTypes {
-#foreach ($p in $props)
+ $serialVersionUID
+
+ #foreach ($p in $props)
@`java.lang.Override`
$p.access $p.type ${p.getter}() {
throw new UnsupportedOperationException(${kindGetter}().toString());
}
-#end
+ #end
}
+#end
#foreach ($p in $props)
@@ -120,6 +124,8 @@
// Implementation when the contained property is "${p}".
private static final class Impl_$p$formalTypes extends Parent_$actualTypes {
+ $serialVersionUID
+
#if ($p.type == "void")
// There is only one instance of this class.
diff --git a/value/src/main/java/com/google/auto/value/processor/autovalue.vm b/value/src/main/java/com/google/auto/value/processor/autovalue.vm
index 6f50e93..86cfe49 100644
--- a/value/src/main/java/com/google/auto/value/processor/autovalue.vm
+++ b/value/src/main/java/com/google/auto/value/processor/autovalue.vm
@@ -177,9 +177,7 @@
}
#end
-#if (!$serialVersionUID.empty)
- private static final long serialVersionUID = $serialVersionUID;
-#end
+ $serialVersionUID
#if ($builderTypeName != "")
@@ -194,241 +192,8 @@
## BUILDER CLASS
- #foreach ($a in $builderAnnotations)
-
- $a##
- #end
-
- static #if ($isFinal) final #end class Builder${builderFormalTypes} ##
- #if ($builderIsInterface) implements #else extends #end
- ${builderTypeName}${builderActualTypes} {
-
- #foreach ($p in $props)
-
- #if ($p.kind.primitive)
-
- private $types.boxedClass($p.typeMirror).simpleName $p;
-
- #else
-
- #if ($builderPropertyBuilders[$p.name])
- ## If you have ImmutableList.Builder<String> stringsBuilder() then we define two fields:
- ## private ImmutableList.Builder<String> stringsBuilder$;
- ## private ImmutableList<String> strings;
-
- private ${builderPropertyBuilders[$p.name].builderType} ##
- ${builderPropertyBuilders[$p.name].name};
-
- #end
-
- private $p.type $p #if ($p.optional && !$p.nullable) = $p.optional.empty #end ;
-
- #end
- #end
-
- Builder() {
- }
-
- #if (!$toBuilderMethods.empty)
-
- private Builder(${origClass}${actualTypes} source) {
-
- #foreach ($p in $props)
-
- this.$p = source.${p.getter}();
-
- #end
-
- }
-
- #end
-
- #foreach ($p in $props)
-
- ## The following is either null or an instance of PropertyBuilderClassifier.PropertyBuilder
- #set ($propertyBuilder = $builderPropertyBuilders[$p.name])
-
- ## Setter and/or property builder
-
- #foreach ($setter in $builderSetters[$p.name])
-
- @`java.lang.Override`
- ${setter.access}${builderTypeName}${builderActualTypes} ##
- ${setter.name}(${setter.nullableAnnotation}$setter.parameterType $p) {
-
- ## Omit null check for primitive, or @Nullable, or if we are going to be calling a copy method
- ## such as Optional.of, which will have its own null check if appropriate.
- #if (!$setter.primitiveParameter && !$p.nullable && ${setter.copy($p)} == $p)
-
- #if ($identifiers)
-
- if ($p == null) {
- throw new NullPointerException("Null $p.name");
- }
- #else
- ## Just throw NullPointerException with no message if it's null.
- ## The Object cast has no effect on the code but silences an ErrorProne warning.
-
- ((`java.lang.Object`) ${p}).getClass();
- #end
-
- #end
-
- #if ($propertyBuilder)
-
- if (${propertyBuilder.name} != null) {
- throw new IllegalStateException(#if ($identifiers)"Cannot set $p after calling ${p.name}Builder()"#end);
- }
-
- #end
-
- this.$p = ${setter.copy($p)};
- return this;
- }
-
- #end
-
- #if ($propertyBuilder)
-
- @`java.lang.Override`
- ${propertyBuilder.access}$propertyBuilder.builderType ${p.name}Builder() {
- if (${propertyBuilder.name} == null) {
-
- ## This is the first time someone has asked for the builder. If the property it sets already
- ## has a value (because it came from a toBuilder() call on the AutoValue class, or because
- ## there is also a setter for this property) then we copy that value into the builder.
- ## Otherwise the builder starts out empty.
- ## If we have neither a setter nor a toBuilder() method, then the builder always starts
- ## off empty.
-
- #if ($builderSetters[$p.name].empty && $toBuilderMethods.empty)
-
- ${propertyBuilder.name} = ${propertyBuilder.initializer};
-
- #else
-
- if ($p == null) {
- ${propertyBuilder.name} = ${propertyBuilder.initializer};
- } else {
-
- #if (${propertyBuilder.builtToBuilder})
-
- ${propertyBuilder.name} = ${p}.${propertyBuilder.builtToBuilder}();
-
- #else
-
- ${propertyBuilder.name} = ${propertyBuilder.initializer};
- ${propertyBuilder.name}.${propertyBuilder.copyAll}($p);
-
- #end
-
- $p = null;
- }
-
- #end
-
- }
- return $propertyBuilder.name;
- }
-
- #end
-
- ## Getter
-
- #if ($builderGetters[$p.name])
-
- @`java.lang.Override`
- ${p.nullableAnnotation}${builderGetters[$p.name].access}$builderGetters[$p.name].type ${p.getter}() {
- #if ($builderGetters[$p.name].optional)
-
- if ($p == null) {
- return $builderGetters[$p.name].optional.empty;
- } else {
- return ${builderGetters[$p.name].optional.rawType}.of($p);
- }
-
- #else
- #if ($builderRequiredProperties.contains($p))
-
- if ($p == null) {
- throw new IllegalStateException(#if ($identifiers)"Property \"$p.name\" has not been set"#end);
- }
-
- #end
-
- #if ($propertyBuilder)
-
- if (${propertyBuilder.name} != null) {
- return ${propertyBuilder.name}.build();
- }
- if ($p == null) {
- ${propertyBuilder.beforeInitDefault}
- $p = ${propertyBuilder.initDefault};
- }
-
- #end
-
- return $p;
-
- #end
-
- }
-
- #end
- #end
-
- @`java.lang.Override`
- ${buildMethod.get().access}${origClass}${actualTypes} ${buildMethod.get().name}() {
-
- #foreach ($p in $props)
- #set ($propertyBuilder = $builderPropertyBuilders[$p.name])
- #if ($propertyBuilder)
-
- if (${propertyBuilder.name} != null) {
- this.$p = ${propertyBuilder.name}.build();
- } else if (this.$p == null) {
- ${propertyBuilder.beforeInitDefault}
- this.$p = ${propertyBuilder.initDefault};
- }
-
- #end
- #end
-
- #if (!$builderRequiredProperties.empty)
- #if ($identifiers) ## build a friendly message showing all missing properties
-
- `java.lang.String` missing = "";
-
- #foreach ($p in $builderRequiredProperties)
-
- if (this.$p == null) {
- missing += " $p.name";
- }
-
- #end
-
- if (!missing.isEmpty()) {
- throw new IllegalStateException("Missing required properties:" + missing);
- }
-
- #else ## just throw an exception if anything is missing
-
- if (#foreach ($p in $builderRequiredProperties)##
- this.$p == null##
- #if ($foreach.hasNext) || #end
- #end) {
- throw new IllegalStateException();
- }
- #end
- #end
-
- return new ${finalSubclass}${actualTypes}(
- #foreach ($p in $props)
-
- this.$p #if ($foreach.hasNext) , #end
- #end );
- }
- }
+ #set($autoBuilder = false)
+ #parse("builder.vm")
#end
}
diff --git a/value/src/main/java/com/google/auto/value/processor/builder.vm b/value/src/main/java/com/google/auto/value/processor/builder.vm
new file mode 100644
index 0000000..630330c
--- /dev/null
+++ b/value/src/main/java/com/google/auto/value/processor/builder.vm
@@ -0,0 +1,285 @@
+## Copyright 2014 Google LLC
+##
+## 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.
+##
+##
+##
+## Template for AutoValue and AutoBuilder builders.
+## This template uses the Apache Velocity Template Language (VTL).
+## The variables ($isFinal, $props, and so on) are defined by the fields of AutoValueOrBuilderTemplateVars.
+##
+## Comments, like this one, begin with ##. The comment text extends up to and including the newline
+## character at the end of the line. So comments also serve to join a line to the next one.
+## Velocity deletes a newline after a directive (#if, #foreach, #end etc) so ## is not needed there.
+## That does mean that we sometimes need an extra blank line after such a directive.
+##
+## Post-processing will remove unwanted spaces and blank lines, but will not join two lines.
+## It will also replace classes spelled as (e.g.) `java.util.Arrays`, with the backquotes, to
+## use just Arrays if that class can be imported unambiguously, or java.util.Arrays if not.
+##
+#foreach ($a in $builderAnnotations)
+$a
+#end
+#if (!$autoBuilder) static #end##
+#if ($isFinal) final #end##
+class ${builderName}${builderFormalTypes} ##
+#if ($builderIsInterface) implements #else extends #end
+ ${builderTypeName}${builderActualTypes} {
+
+#foreach ($p in $props)
+
+ #if ($p.kind.primitive)
+
+ private $types.boxedClass($p.typeMirror).simpleName $p;
+
+ #else
+
+ #if ($builderPropertyBuilders[$p.name])
+ ## If you have ImmutableList.Builder<String> stringsBuilder() then we define two fields:
+ ## private ImmutableList.Builder<String> stringsBuilder$;
+ ## private ImmutableList<String> strings;
+
+ private ${builderPropertyBuilders[$p.name].builderType} ##
+ ${builderPropertyBuilders[$p.name].name};
+
+ #end
+
+ private $p.type $p #if ($p.optional && !$p.nullable) = $p.optional.empty #end ;
+
+ #end
+#end
+
+ ${builderName}() {
+ }
+
+#if ($toBuilderConstructor)
+
+ private ${builderName}(${origClass}${actualTypes} source) {
+
+ #foreach ($p in $props)
+
+ this.$p = source.${p.getter}();
+
+ #end
+
+ }
+
+#end
+
+#foreach ($p in $props)
+
+ ## The following is either null or an instance of PropertyBuilderClassifier.PropertyBuilder
+ #set ($propertyBuilder = $builderPropertyBuilders[$p.name])
+
+ ## Setter and/or property builder
+
+ #foreach ($setter in $builderSetters[$p.name])
+
+ @`java.lang.Override`
+ ${setter.access}${builderTypeName}${builderActualTypes} ##
+ ${setter.name}(${setter.nullableAnnotation}$setter.parameterType $p) {
+
+ ## Omit null check for primitive, or @Nullable, or if we are going to be calling a copy method
+ ## such as Optional.of, which will have its own null check if appropriate.
+ #if (!$setter.primitiveParameter && !$p.nullable && ${setter.copy($p)} == $p)
+
+ #if ($identifiers)
+
+ if ($p == null) {
+ throw new NullPointerException("Null $p.name");
+ }
+ #else
+ ## Just throw NullPointerException with no message if it's null.
+ ## The Object cast has no effect on the code but silences an ErrorProne warning.
+
+ ((`java.lang.Object`) ${p}).getClass();
+ #end
+
+ #end
+
+ #if ($propertyBuilder)
+
+ if (${propertyBuilder.name} != null) {
+ throw new IllegalStateException(#if ($identifiers)"Cannot set $p after calling ${p.name}Builder()"#end);
+ }
+
+ #end
+
+ this.$p = ${setter.copy($p)};
+ return this;
+ }
+
+ #end
+
+ #if ($propertyBuilder)
+
+ @`java.lang.Override`
+ ${propertyBuilder.access}$propertyBuilder.builderType ${p.name}Builder($propertyBuilder.propertyBuilderMethodParameters) {
+ if (${propertyBuilder.name} == null) {
+
+ ## This is the first time someone has asked for the builder. If the property it sets already
+ ## has a value (because it came from a toBuilder() call on the AutoValue class, or because
+ ## there is also a setter for this property) then we copy that value into the builder.
+ ## Otherwise the builder starts out empty.
+ ## If we have neither a setter nor a toBuilder() method, then the builder always starts
+ ## off empty.
+
+ #if ($builderSetters[$p.name].empty && $toBuilderMethods.empty)
+
+ ${propertyBuilder.name} = ${propertyBuilder.initializer};
+
+ #else
+
+ if ($p == null) {
+ ${propertyBuilder.name} = ${propertyBuilder.initializer};
+ } else {
+
+ #if (${propertyBuilder.builtToBuilder})
+
+ ${propertyBuilder.name} = ${p}.${propertyBuilder.builtToBuilder}();
+
+ #else
+
+ ${propertyBuilder.name} = ${propertyBuilder.initializer};
+ ${propertyBuilder.name}.${propertyBuilder.copyAll}($p);
+
+ #end
+
+ $p = null;
+ }
+
+ #end
+
+ } #if (!$propertyBuilder.propertyBuilderMethodParameters.empty) else {
+ ## This check only happens if the property-builder method has a parameter.
+ ## We don't know if the existing builder was created with the same parameter,
+ ## so we throw to avoid possibly giving you a builder that is different from
+ ## the one you asked for.
+
+ throw new IllegalStateException("Property builder for $p.name is already defined");
+ }
+ #end
+
+ return $propertyBuilder.name;
+ }
+
+ #end
+
+ ## Getter
+
+ #if ($builderGetters[$p.name])
+
+ @`java.lang.Override`
+ ${p.nullableAnnotation}${builderGetters[$p.name].access}$builderGetters[$p.name].type ${p.getter}() {
+ #if ($builderGetters[$p.name].optional)
+
+ if ($p == null) {
+ return $builderGetters[$p.name].optional.empty;
+ } else {
+ return ${builderGetters[$p.name].optional.rawType}.of($p);
+ }
+
+ #else
+ #if ($builderRequiredProperties.contains($p))
+
+ if ($p == null) {
+ throw new IllegalStateException(#if ($identifiers)"Property \"$p.name\" has not been set"#end);
+ }
+
+ #end
+
+ #if ($propertyBuilder)
+
+ if (${propertyBuilder.name} != null) {
+ return ${propertyBuilder.name}.build();
+ }
+ if ($p == null) {
+ ${propertyBuilder.beforeInitDefault}
+ $p = ${propertyBuilder.initDefault};
+ }
+
+ #end
+
+ return $p;
+
+ #end
+
+ }
+
+ #end
+#end
+
+## build() method
+
+ @`java.lang.Override`
+ ${buildMethod.get().access}${builtType} ${buildMethod.get().name}() ${buildMethod.get().throws} {
+
+#foreach ($p in $props)
+ #set ($propertyBuilder = $builderPropertyBuilders[$p.name])
+ #if ($propertyBuilder)
+
+ if (${propertyBuilder.name} != null) {
+ this.$p = ${propertyBuilder.name}.build();
+ } else if (this.$p == null) {
+ ${propertyBuilder.beforeInitDefault}
+ this.$p = ${propertyBuilder.initDefault};
+ }
+
+ #end
+#end
+
+#if (!$builderRequiredProperties.empty)
+ if (#foreach ($p in $builderRequiredProperties)##
+ this.$p == null##
+ #if ($foreach.hasNext)
+
+ || #end
+ #end) {
+
+ #if ($identifiers) ## build a friendly message showing all missing properties
+ #if ($builderRequiredProperties.size() == 1)
+
+ `java.lang.String` missing = " $builderRequiredProperties.iterator().next()";
+
+ #else
+
+ `java.lang.StringBuilder` missing = new `java.lang.StringBuilder`();
+
+ #foreach ($p in $builderRequiredProperties)
+
+ if (this.$p == null) {
+ missing.append(" $p.name");
+ }
+
+ #end
+ #end
+
+ throw new IllegalStateException("Missing required properties:" + missing);
+
+ #else ## just throw an exception if anything is missing
+
+ throw new IllegalStateException();
+
+ #end
+
+ }
+
+#end
+
+ #if ($builtType != "void") return #end ${build}(
+#foreach ($p in $props)
+
+ this.$p #if ($foreach.hasNext) , #end
+#end );
+ }
+}
diff --git a/value/src/main/java/com/google/auto/value/processor/equalshashcode.vm b/value/src/main/java/com/google/auto/value/processor/equalshashcode.vm
index 094f6c3..03e25c2 100644
--- a/value/src/main/java/com/google/auto/value/processor/equalshashcode.vm
+++ b/value/src/main/java/com/google/auto/value/processor/equalshashcode.vm
@@ -49,7 +49,7 @@
this.$p == that.${p.getter}() ##
#elseif ($p.kind == "ARRAY")
`java.util.Arrays`.equals(this.$p, ##
- (that instanceof $subclass) ? (($subclass) that).$p : that.${p.getter}()) ##
+ (that instanceof $subclass) ? (($subclass$wildcardTypes) that).$p : that.${p.getter}()) ##
#elseif ($p.nullable)
(this.$p == null ? that.${p.getter}() == null : this.${p}.equals(that.${p.getter}())) ##
#else
diff --git a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java
index 18c7736..5d1462d 100644
--- a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java
+++ b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedMethodSubject.java
@@ -51,9 +51,6 @@
javac()
.withProcessors(new AutoValueProcessor(ImmutableList.of(new MemoizeExtension())))
.compile(file);
- assertThat(compilation)
- .hadErrorContaining(error)
- .inFile(file)
- .onLineContaining(actual);
+ assertThat(compilation).hadErrorContaining(error).inFile(file).onLineContaining(actual);
}
}
diff --git a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java
index 7bd61ac..5beb686 100644
--- a/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java
+++ b/value/src/test/java/com/google/auto/value/extension/memoized/MemoizedTest.java
@@ -22,6 +22,8 @@
import com.google.auto.value.AutoValue.CopyAnnotations;
import com.google.auto.value.extension.memoized.MemoizedTest.HashCodeEqualsOptimization.EqualsCounter;
import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.Immutable;
+import com.google.errorprone.annotations.ImmutableTypeParameter;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
@@ -123,7 +125,9 @@
@org.checkerframework.checker.nullness.qual.Nullable
String nullableWithTypeAnnotation() {
nullableWithTypeAnnotationCount++;
- return "nullable derived " + stringWithTypeAnnotation() + " "
+ return "nullable derived "
+ + stringWithTypeAnnotation()
+ + " "
+ nullableWithTypeAnnotationCount;
}
@@ -234,8 +238,9 @@
@Before
public void setUp() {
- value = new AutoValue_MemoizedTest_Value(
- "string", "stringWithTypeAnnotation", new HashCodeAndToStringCounter());
+ value =
+ new AutoValue_MemoizedTest_Value(
+ "string", "stringWithTypeAnnotation", new HashCodeAndToStringCounter());
listValue = new AutoValue_MemoizedTest_ListValue<Integer, String>(0, "hello");
}
@@ -375,8 +380,9 @@
Method nullable =
AutoValue_MemoizedTest_Value.class.getDeclaredMethod("nullableWithTypeAnnotation");
AnnotatedType returnType = nullable.getAnnotatedReturnType();
- assertThat(returnType.isAnnotationPresent(
- org.checkerframework.checker.nullness.qual.Nullable.class))
+ assertThat(
+ returnType.isAnnotationPresent(
+ org.checkerframework.checker.nullness.qual.Nullable.class))
.isTrue();
}
@@ -387,11 +393,13 @@
// [1] @org.checkerframework.checker.nullness.qual.Nullable String stringWithTypeAnnotation,
// [2] HashCodeAndToStringCounter counter
// We don't currently copy @javax.annotation.Nullable because it is not a TYPE_USE annotation.
- Constructor<?> constructor = AutoValue_MemoizedTest_Value.class.getDeclaredConstructor(
- String.class, String.class, HashCodeAndToStringCounter.class);
+ Constructor<?> constructor =
+ AutoValue_MemoizedTest_Value.class.getDeclaredConstructor(
+ String.class, String.class, HashCodeAndToStringCounter.class);
AnnotatedType paramType = constructor.getAnnotatedParameterTypes()[1];
- assertThat(paramType.isAnnotationPresent(
- org.checkerframework.checker.nullness.qual.Nullable.class))
+ assertThat(
+ paramType.isAnnotationPresent(
+ org.checkerframework.checker.nullness.qual.Nullable.class))
.isTrue();
}
@@ -448,8 +456,8 @@
assertThat(memoizedHashCodeAndFinalEqualsMethod.equals(second)).isTrue();
assertThat(memoizedHashCodeAndFinalEqualsMethod.hashCodeCount).isEqualTo(0);
- memoizedHashCodeAndFinalEqualsMethod.hashCode();
- memoizedHashCodeAndFinalEqualsMethod.hashCode();
+ int unused1 = memoizedHashCodeAndFinalEqualsMethod.hashCode();
+ int unused2 = memoizedHashCodeAndFinalEqualsMethod.hashCode();
assertThat(memoizedHashCodeAndFinalEqualsMethod.hashCodeCount).isEqualTo(1);
}
@@ -465,8 +473,7 @@
@AutoValue
abstract static class ResourceUriPath<InputT> extends AbstractTypePath<InputT, ResourceUri> {
- static <InputT> ResourceUriPath<InputT> create(
- TypeEdgeIterable<InputT, ResourceUri> edges) {
+ static <InputT> ResourceUriPath<InputT> create(TypeEdgeIterable<InputT, ResourceUri> edges) {
return new AutoValue_MemoizedTest_ResourceUriPath<>(edges);
}
@@ -482,4 +489,27 @@
ResourceUriPath.create(new TypeEdgeIterable<String, ResourceUri>() {});
assertThat(path.edges()).isNotNull();
}
+
+ @Immutable
+ @AutoValue
+ abstract static class Unchanging<@ImmutableTypeParameter T> {
+ abstract T value();
+
+ @Override
+ @Memoized
+ public abstract int hashCode();
+
+ static <@ImmutableTypeParameter T> Unchanging<T> of(T value) {
+ return new AutoValue_MemoizedTest_Unchanging<T>(value);
+ }
+ }
+
+ @Test
+ public void copiedTypeAnnotations() {
+ for (Class<?> c = Unchanging.of("foo").getClass(); c != Object.class; c = c.getSuperclass()) {
+ assertThat(c.getTypeParameters()).hasLength(1);
+ assertThat(c.getTypeParameters()[0].isAnnotationPresent(ImmutableTypeParameter.class))
+ .isTrue();
+ }
+ }
}
diff --git a/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java b/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java
index 1879d1e..064406d 100644
--- a/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java
+++ b/value/src/test/java/com/google/auto/value/extension/serializable/processor/SerializableAutoValueExtensionTest.java
@@ -415,4 +415,38 @@
assertThat(actualAutoValue).isEqualTo(autoValue);
}
+
+ /**
+ * Type that may result in nested lambdas in the generated code. Including this allows us to
+ * verify that we handle those correctly, in particular not reusing a lambda parameter name in
+ * another lambda nested inside the first one.
+ */
+ @SerializableAutoValue
+ @AutoValue
+ abstract static class ComplexType implements Serializable {
+ abstract ImmutableMap<String, ImmutableMap<String, Optional<String>>> a();
+
+ static ComplexType.Builder builder() {
+ return new AutoValue_SerializableAutoValueExtensionTest_ComplexType.Builder();
+ }
+
+ @AutoValue.Builder
+ abstract static class Builder {
+ abstract ComplexType.Builder setA(
+ ImmutableMap<String, ImmutableMap<String, Optional<String>>> a);
+
+ abstract ComplexType build();
+ }
+ }
+
+ @Test
+ public void complexType() {
+ ImmutableMap<String, ImmutableMap<String, Optional<String>>> map =
+ ImmutableMap.of("foo", ImmutableMap.of("bar", Optional.of("baz")));
+ ComplexType complexType = ComplexType.builder().setA(map).build();
+
+ ComplexType reserialized = SerializableTester.reserialize(complexType);
+
+ assertThat(reserialized).isEqualTo(complexType);
+ }
}
diff --git a/value/src/test/java/com/google/auto/value/extension/serializable/serializer/utils/FakeSerializerFactory.java b/value/src/test/java/com/google/auto/value/extension/serializable/serializer/utils/FakeSerializerFactory.java
index 388977f..162d7cf 100644
--- a/value/src/test/java/com/google/auto/value/extension/serializable/serializer/utils/FakeSerializerFactory.java
+++ b/value/src/test/java/com/google/auto/value/extension/serializable/serializer/utils/FakeSerializerFactory.java
@@ -42,6 +42,15 @@
return new FakeIdentitySerializer(type, isIdentity);
}
+ // This doesn't follow the contract, and always returns the same string for a given prefix.
+ // That means it will be wrong if two identifiers with the same prefix are in the same scope in
+ // the generated code, but for our purposes in this fake it is OK, and means we don't have to
+ // hardwire knowledge of the uniqueness algorithm into golden text in tests.
+ @Override
+ public CodeBlock newIdentifier(String prefix) {
+ return CodeBlock.of("$L$$", prefix);
+ }
+
private static class FakeIdentitySerializer implements Serializer {
private final TypeMirror typeMirror;
diff --git a/value/src/test/java/com/google/auto/value/extension/toprettystring/ToPrettyStringTest.java b/value/src/test/java/com/google/auto/value/extension/toprettystring/ToPrettyStringTest.java
new file mode 100644
index 0000000..f519747
--- /dev/null
+++ b/value/src/test/java/com/google/auto/value/extension/toprettystring/ToPrettyStringTest.java
@@ -0,0 +1,961 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.toprettystring.ToPrettyStringTest.CollectionSubtypesWithFixedTypeParameters.StringList;
+import com.google.auto.value.extension.toprettystring.ToPrettyStringTest.CollectionSubtypesWithFixedTypeParameters.StringMap;
+import com.google.auto.value.extension.toprettystring.ToPrettyStringTest.PropertyHasToPrettyString.HasToPrettyString;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.primitives.ImmutableIntArray;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@SuppressWarnings("AutoValueImmutableFields")
+@RunWith(JUnit4.class)
+public class ToPrettyStringTest {
+ @AutoValue
+ abstract static class Primitives {
+ abstract int i();
+
+ abstract long l();
+
+ abstract byte b();
+
+ abstract short s();
+
+ abstract char c();
+
+ abstract float f();
+
+ abstract double d();
+
+ abstract boolean bool();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void primitives() {
+ Primitives valueType =
+ new AutoValue_ToPrettyStringTest_Primitives(
+ 1, 2L, (byte) 3, (short) 4, 'C', 6.6f, 7.7, false);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "Primitives {"
+ + "\n i = 1,"
+ + "\n l = 2,"
+ + "\n b = 3,"
+ + "\n s = 4,"
+ + "\n c = C,"
+ + "\n f = 6.6,"
+ + "\n d = 7.7,"
+ + "\n bool = false,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class PrimitiveArray {
+ @Nullable
+ @SuppressWarnings("mutable")
+ abstract long[] longs();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void primitiveArray() {
+ PrimitiveArray valueType =
+ new AutoValue_ToPrettyStringTest_PrimitiveArray(new long[] {1L, 2L, 10L, 200L});
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrimitiveArray {"
+ + "\n longs = ["
+ + "\n 1,"
+ + "\n 2,"
+ + "\n 10,"
+ + "\n 200,"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void primitiveArray_empty() {
+ PrimitiveArray valueType = new AutoValue_ToPrettyStringTest_PrimitiveArray(new long[0]);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrimitiveArray {" // force newline
+ + "\n longs = [],"
+ + "\n}");
+ }
+
+ @Test
+ public void primitiveArray_null() {
+ PrimitiveArray valueType = new AutoValue_ToPrettyStringTest_PrimitiveArray(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrimitiveArray {" // force newline
+ + "\n longs = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class PrettyCollection {
+ @Nullable
+ abstract Collection<Object> collection();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void prettyCollection() {
+ PrettyCollection valueType =
+ new AutoValue_ToPrettyStringTest_PrettyCollection(ImmutableList.of("hello", "world"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyCollection {"
+ + "\n collection = ["
+ + "\n hello,"
+ + "\n world,"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyCollection_elementsWithNewlines() {
+ PrettyCollection valueType =
+ new AutoValue_ToPrettyStringTest_PrettyCollection(
+ ImmutableList.of("hello\nworld\nnewline"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyCollection {"
+ + "\n collection = ["
+ + "\n hello"
+ + "\n world"
+ + "\n newline,"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyCollection_empty() {
+ PrettyCollection valueType =
+ new AutoValue_ToPrettyStringTest_PrettyCollection(ImmutableList.of());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyCollection {" // force newline
+ + "\n collection = [],"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyCollection_null() {
+ PrettyCollection valueType = new AutoValue_ToPrettyStringTest_PrettyCollection(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyCollection {" // force newline
+ + "\n collection = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class NestedCollection {
+ @Nullable
+ abstract Collection<Collection<Object>> nestedCollection();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void nestedCollection() {
+ NestedCollection valueType =
+ new AutoValue_ToPrettyStringTest_NestedCollection(
+ Arrays.asList(
+ ImmutableList.of("hello", "world"),
+ ImmutableList.of("hello2", "world2"),
+ null,
+ Arrays.asList("not null", null)));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "NestedCollection {"
+ + "\n nestedCollection = ["
+ + "\n ["
+ + "\n hello,"
+ + "\n world,"
+ + "\n ],"
+ + "\n ["
+ + "\n hello2,"
+ + "\n world2,"
+ + "\n ],"
+ + "\n null,"
+ + "\n ["
+ + "\n not null,"
+ + "\n null,"
+ + "\n ],"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void nestedCollection_elementsWithNewlines() {
+ NestedCollection valueType =
+ new AutoValue_ToPrettyStringTest_NestedCollection(
+ ImmutableList.of(
+ ImmutableList.of((Object) "hello\nworld\nnewline", "hello2\nworld2\nnewline2")));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "NestedCollection {"
+ + "\n nestedCollection = ["
+ + "\n ["
+ + "\n hello"
+ + "\n world"
+ + "\n newline,"
+ + "\n hello2"
+ + "\n world2"
+ + "\n newline2,"
+ + "\n ],"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void nestedCollection_empty() {
+ NestedCollection valueType =
+ new AutoValue_ToPrettyStringTest_NestedCollection(ImmutableList.of());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "NestedCollection {" // force newline
+ + "\n nestedCollection = [],"
+ + "\n}");
+ }
+
+ @Test
+ public void nestedCollection_nestedEmpty() {
+ NestedCollection valueType =
+ new AutoValue_ToPrettyStringTest_NestedCollection(
+ ImmutableList.of(ImmutableList.of(), ImmutableList.of()));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "NestedCollection {"
+ + "\n nestedCollection = ["
+ + "\n [],"
+ + "\n [],"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void nestedCollection_null() {
+ NestedCollection valueType = new AutoValue_ToPrettyStringTest_NestedCollection(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "NestedCollection {" // force newline
+ + "\n nestedCollection = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class ImmutablePrimitiveArray {
+ @Nullable
+ abstract ImmutableIntArray immutableIntArray();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void immutablePrimitiveArray() {
+ ImmutablePrimitiveArray valueType =
+ new AutoValue_ToPrettyStringTest_ImmutablePrimitiveArray(ImmutableIntArray.of(1, 2));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "ImmutablePrimitiveArray {"
+ + "\n immutableIntArray = ["
+ + "\n 1,"
+ + "\n 2,"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @Test
+ public void immutablePrimitiveArray_empty() {
+ ImmutablePrimitiveArray valueType =
+ new AutoValue_ToPrettyStringTest_ImmutablePrimitiveArray(ImmutableIntArray.of());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "ImmutablePrimitiveArray {" // force newline
+ + "\n immutableIntArray = [],"
+ + "\n}");
+ }
+
+ @Test
+ public void immutablePrimitiveArray_null() {
+ ImmutablePrimitiveArray valueType =
+ new AutoValue_ToPrettyStringTest_ImmutablePrimitiveArray(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "ImmutablePrimitiveArray {" // force newline
+ + "\n immutableIntArray = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class PrettyMap {
+ @Nullable
+ abstract Map<Object, Object> map();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void prettyMap() {
+ PrettyMap valueType = new AutoValue_ToPrettyStringTest_PrettyMap(ImmutableMap.of(1, 2));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMap {" // force newline
+ + "\n map = {"
+ + "\n 1: 2,"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyMap_keysAndValuesWithNewlines() {
+ PrettyMap valueType =
+ new AutoValue_ToPrettyStringTest_PrettyMap(
+ ImmutableMap.of(
+ "key1\nnewline", "value1\nnewline", "key2\nnewline", "value2\nnewline"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMap {"
+ + "\n map = {"
+ + "\n key1"
+ + "\n newline: value1"
+ + "\n newline,"
+ + "\n key2"
+ + "\n newline: value2"
+ + "\n newline,"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyMap_empty() {
+ PrettyMap valueType = new AutoValue_ToPrettyStringTest_PrettyMap(ImmutableMap.of());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMap {" // force newline
+ + "\n map = {},"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyMap_null() {
+ PrettyMap valueType = new AutoValue_ToPrettyStringTest_PrettyMap(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMap {" // force newline
+ + "\n map = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class MapOfMaps {
+ @Nullable
+ abstract Map<Map<Object, Object>, Map<Object, Object>> mapOfMaps();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ private static <K, V> Map<K, V> mapWithNulls(K k, V v) {
+ Map<K, V> map = new LinkedHashMap<>();
+ map.put(k, v);
+ return map;
+ }
+
+ @Test
+ public void mapOfMaps() {
+ Map<Map<Object, Object>, Map<Object, Object>> mapOfMaps = new LinkedHashMap<>();
+ mapOfMaps.put(ImmutableMap.of("k1_k", "k1_v"), ImmutableMap.of("v1_k", "v1_v"));
+ mapOfMaps.put(ImmutableMap.of("k2_k", "k2_v"), ImmutableMap.of("v2_k", "v2_v"));
+ mapOfMaps.put(mapWithNulls("keyForNullValue", null), mapWithNulls(null, "valueForNullKey"));
+ mapOfMaps.put(null, ImmutableMap.of("nullKeyKey", "nullKeyValue"));
+ mapOfMaps.put(ImmutableMap.of("nullValueKey", "nullValueValue"), null);
+ mapOfMaps.put(
+ ImmutableMap.of("keyForMapOfNullsKey", "keyForMapOfNullsValue"), mapWithNulls(null, null));
+ MapOfMaps valueType = new AutoValue_ToPrettyStringTest_MapOfMaps(mapOfMaps);
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "MapOfMaps {"
+ + "\n mapOfMaps = {"
+ + "\n {"
+ + "\n k1_k: k1_v,"
+ + "\n }: {"
+ + "\n v1_k: v1_v,"
+ + "\n },"
+ + "\n {"
+ + "\n k2_k: k2_v,"
+ + "\n }: {"
+ + "\n v2_k: v2_v,"
+ + "\n },"
+ + "\n {"
+ + "\n keyForNullValue: null,"
+ + "\n }: {"
+ + "\n null: valueForNullKey,"
+ + "\n },"
+ + "\n null: {"
+ + "\n nullKeyKey: nullKeyValue,"
+ + "\n },"
+ + "\n {"
+ + "\n nullValueKey: nullValueValue,"
+ + "\n }: null,"
+ + "\n {"
+ + "\n keyForMapOfNullsKey: keyForMapOfNullsValue,"
+ + "\n }: {"
+ + "\n null: null,"
+ + "\n },"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void mapOfMaps_elementsWithNewlines() {
+ MapOfMaps valueType =
+ new AutoValue_ToPrettyStringTest_MapOfMaps(
+ ImmutableMap.of(
+ ImmutableMap.of((Object) "k_k\nnewline", (Object) "k_v\nnewline"),
+ ImmutableMap.of((Object) "v_k\nnewline", (Object) "v_v\nnewline")));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "MapOfMaps {"
+ + "\n mapOfMaps = {"
+ + "\n {"
+ + "\n k_k"
+ + "\n newline: k_v"
+ + "\n newline,"
+ + "\n }: {"
+ + "\n v_k"
+ + "\n newline: v_v"
+ + "\n newline,"
+ + "\n },"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void mapOfMaps_empty() {
+ MapOfMaps valueType = new AutoValue_ToPrettyStringTest_MapOfMaps(ImmutableMap.of());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "MapOfMaps {" // force newline
+ + "\n mapOfMaps = {},"
+ + "\n}");
+ }
+
+ @Test
+ public void mapOfMaps_nestedEmpty() {
+ MapOfMaps valueType =
+ new AutoValue_ToPrettyStringTest_MapOfMaps(
+ ImmutableMap.of(ImmutableMap.of(), ImmutableMap.of()));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "MapOfMaps {" // force newline
+ + "\n mapOfMaps = {"
+ + "\n {}: {},"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void mapOfMaps_null() {
+ MapOfMaps valueType = new AutoValue_ToPrettyStringTest_MapOfMaps(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "MapOfMaps {" // force newline
+ + "\n mapOfMaps = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class PrettyMultimap {
+ @Nullable
+ abstract Multimap<Object, Object> multimap();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void prettyMultimap() {
+ PrettyMultimap valueType =
+ new AutoValue_ToPrettyStringTest_PrettyMultimap(
+ ImmutableMultimap.builder().putAll("k", "v1", "v2").build());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMultimap {" // force newline
+ + "\n multimap = {"
+ + "\n k: ["
+ + "\n v1,"
+ + "\n v2,"
+ + "\n ],"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyMultimap_keysAndValuesWithNewlines() {
+ PrettyMultimap valueType =
+ new AutoValue_ToPrettyStringTest_PrettyMultimap(
+ ImmutableMultimap.builder()
+ .putAll("key\nnewline", "value1\nnewline", "value2\nnewline")
+ .build());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMultimap {"
+ + "\n multimap = {"
+ + "\n key"
+ + "\n newline: ["
+ + "\n value1"
+ + "\n newline,"
+ + "\n value2"
+ + "\n newline,"
+ + "\n ],"
+ + "\n },"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyMultimap_empty() {
+ PrettyMultimap valueType =
+ new AutoValue_ToPrettyStringTest_PrettyMultimap(ImmutableMultimap.of());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMultimap {" // force newline
+ + "\n multimap = {},"
+ + "\n}");
+ }
+
+ @Test
+ public void prettyMultimap_null() {
+ PrettyMultimap valueType = new AutoValue_ToPrettyStringTest_PrettyMultimap(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PrettyMultimap {" // force newline
+ + "\n multimap = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class JavaOptional {
+ @Nullable
+ abstract java.util.Optional<Object> optional();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void javaOptional_present() {
+ JavaOptional valueType =
+ new AutoValue_ToPrettyStringTest_JavaOptional(java.util.Optional.of("hello, world"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "JavaOptional {" // force newline
+ + "\n optional = hello, world,"
+ + "\n}");
+ }
+
+ @Test
+ public void javaOptional_empty() {
+ JavaOptional valueType =
+ new AutoValue_ToPrettyStringTest_JavaOptional(java.util.Optional.empty());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "JavaOptional {" // force newline
+ + "\n optional = <empty>,"
+ + "\n}");
+ }
+
+ @Test
+ public void javaOptional_valueWithNewlines() {
+ JavaOptional valueType =
+ new AutoValue_ToPrettyStringTest_JavaOptional(
+ java.util.Optional.of("optional\nwith\nnewline"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "JavaOptional {" // force newline
+ + "\n optional = optional"
+ + "\n with"
+ + "\n newline,"
+ + "\n}");
+ }
+
+ @Test
+ public void javaOptional_null() {
+ @SuppressWarnings("NullOptional")
+ JavaOptional valueType = new AutoValue_ToPrettyStringTest_JavaOptional(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "JavaOptional {" // force newline
+ + "\n optional = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class GuavaOptional {
+ @Nullable
+ abstract com.google.common.base.Optional<Object> optional();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void guavaOptional_present() {
+ GuavaOptional valueType =
+ new AutoValue_ToPrettyStringTest_GuavaOptional(
+ com.google.common.base.Optional.of("hello, world"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "GuavaOptional {" // force newline
+ + "\n optional = hello, world,"
+ + "\n}");
+ }
+
+ @Test
+ public void guavaOptional_absent() {
+ GuavaOptional valueType =
+ new AutoValue_ToPrettyStringTest_GuavaOptional(com.google.common.base.Optional.absent());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "GuavaOptional {" // force newline
+ + "\n optional = <absent>,"
+ + "\n}");
+ }
+
+ @Test
+ public void guavaOptional_valueWithNewlines() {
+ GuavaOptional valueType =
+ new AutoValue_ToPrettyStringTest_GuavaOptional(
+ com.google.common.base.Optional.of("optional\nwith\nnewline"));
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "GuavaOptional {" // force newline
+ + "\n optional = optional"
+ + "\n with"
+ + "\n newline,"
+ + "\n}");
+ }
+
+ @Test
+ public void guavaOptional_null() {
+ @SuppressWarnings("NullOptional")
+ GuavaOptional valueType = new AutoValue_ToPrettyStringTest_GuavaOptional(null);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "GuavaOptional {" // force newline
+ + "\n optional = null,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class NestAllTheThings {
+ @Nullable
+ abstract com.google.common.base.Optional<
+ java.util.Optional<
+ List< // open list
+ Map<ImmutableIntArray, Multimap<int[][], Object>>
+ // close list
+ >>>
+ value();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void nestAllTheThings() {
+ NestAllTheThings valueType =
+ new AutoValue_ToPrettyStringTest_NestAllTheThings(
+ com.google.common.base.Optional.of(
+ java.util.Optional.of(
+ ImmutableList.of(
+ ImmutableMap.of(
+ ImmutableIntArray.of(-1, -2, -3),
+ ImmutableMultimap.of(
+ new int[][] {{1, 2}, {3, 4, 5}, {}}, "value\nwith\nnewline"))))));
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "NestAllTheThings {"
+ + "\n value = ["
+ + "\n {"
+ + "\n ["
+ + "\n -1,"
+ + "\n -2,"
+ + "\n -3,"
+ + "\n ]: {"
+ + "\n ["
+ + "\n ["
+ + "\n 1,"
+ + "\n 2,"
+ + "\n ],"
+ + "\n ["
+ + "\n 3,"
+ + "\n 4,"
+ + "\n 5,"
+ + "\n ],"
+ + "\n [],"
+ + "\n ]: ["
+ + "\n value"
+ + "\n with"
+ + "\n newline,"
+ + "\n ],"
+ + "\n },"
+ + "\n },"
+ + "\n ],"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class WithCustomName {
+ abstract int i();
+
+ @ToPrettyString
+ abstract String customName();
+ }
+
+ @Test
+ public void withCustomName() {
+ WithCustomName valueType = new AutoValue_ToPrettyStringTest_WithCustomName(1);
+
+ assertThat(valueType.customName())
+ .isEqualTo(
+ "WithCustomName {" // force newline
+ + "\n i = 1,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class OverridesToString {
+ abstract int i();
+
+ @ToPrettyString
+ @Override
+ public abstract String toString();
+ }
+
+ @Test
+ public void overridesToString() {
+ OverridesToString valueType = new AutoValue_ToPrettyStringTest_OverridesToString(1);
+
+ assertThat(valueType.toString())
+ .isEqualTo(
+ "OverridesToString {" // force newline
+ + "\n i = 1,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class PropertyHasToPrettyString {
+ static class HasToPrettyString<A> {
+ @Override
+ public String toString() {
+ throw new AssertionError();
+ }
+
+ @ToPrettyString
+ String toPrettyString() {
+ return "custom\n@ToPrettyString\nmethod";
+ }
+ }
+
+ static class HasInheritedToPrettyString extends HasToPrettyString<String> {}
+
+ interface HasToPrettyStringInInterface {
+ @ToPrettyString
+ default String toPrettyString() {
+ return "custom\n@ToPrettyString\nmethod\ninterface";
+ }
+ }
+
+ static class HasToPrettyStringFromSuperInterface implements HasToPrettyStringInInterface {}
+
+ abstract HasToPrettyString<String> parameterizedWithString();
+
+ abstract HasToPrettyString<Void> parameterizedWithVoid();
+
+ abstract HasInheritedToPrettyString superclass();
+
+ abstract HasToPrettyStringFromSuperInterface superinterface();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void propertyHasToPrettyString() {
+ PropertyHasToPrettyString valueType =
+ new AutoValue_ToPrettyStringTest_PropertyHasToPrettyString(
+ new PropertyHasToPrettyString.HasToPrettyString<>(),
+ new PropertyHasToPrettyString.HasToPrettyString<>(),
+ new PropertyHasToPrettyString.HasInheritedToPrettyString(),
+ new PropertyHasToPrettyString.HasToPrettyStringFromSuperInterface());
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "PropertyHasToPrettyString {"
+ + "\n parameterizedWithString = custom"
+ + "\n @ToPrettyString"
+ + "\n method,"
+ + "\n parameterizedWithVoid = custom"
+ + "\n @ToPrettyString"
+ + "\n method,"
+ + "\n superclass = custom"
+ + "\n @ToPrettyString"
+ + "\n method,"
+ + "\n superinterface = custom"
+ + "\n @ToPrettyString"
+ + "\n method"
+ + "\n interface,"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class CollectionSubtypesWithFixedTypeParameters {
+ static class StringList extends ArrayList<String> {}
+
+ static class StringMap extends LinkedHashMap<String, String> {}
+
+ abstract StringList list();
+
+ abstract StringMap map();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void fixedTypeParameters() {
+ StringList stringList = new StringList();
+ stringList.addAll(ImmutableList.of("a", "b", "c"));
+ StringMap stringMap = new StringMap();
+ stringMap.putAll(ImmutableMap.of("A", "a", "B", "b"));
+ CollectionSubtypesWithFixedTypeParameters valueType =
+ new AutoValue_ToPrettyStringTest_CollectionSubtypesWithFixedTypeParameters(
+ stringList, stringMap);
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "CollectionSubtypesWithFixedTypeParameters {"
+ + "\n list = ["
+ + "\n a,"
+ + "\n b,"
+ + "\n c,"
+ + "\n ],"
+ + "\n map = {"
+ + "\n A: a,"
+ + "\n B: b,"
+ + "\n },"
+ + "\n}");
+ }
+
+ @AutoValue
+ abstract static class JavaBeans {
+ abstract int getInt();
+
+ abstract boolean isBoolean();
+
+ abstract String getNotAJavaIdentifier();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+ }
+
+ @Test
+ public void javaBeans() {
+ JavaBeans valueType = new AutoValue_ToPrettyStringTest_JavaBeans(4, false, "not");
+
+ assertThat(valueType.toPrettyString())
+ .isEqualTo(
+ "JavaBeans {"
+ + "\n int = 4,"
+ + "\n boolean = false,"
+ + "\n notAJavaIdentifier = not,"
+ + "\n}");
+
+ // Check to make sure that we use the same property names that AutoValue does. This is mostly
+ // defensive, since in some scenarios AutoValue considers the property names of a java bean as
+ // having the prefix removed.
+ assertThat(valueType.toString())
+ .isEqualTo("JavaBeans{int=4, boolean=false, notAJavaIdentifier=not}");
+ }
+}
diff --git a/value/src/test/java/com/google/auto/value/extension/toprettystring/ToPrettyStringValidatorTest.java b/value/src/test/java/com/google/auto/value/extension/toprettystring/ToPrettyStringValidatorTest.java
new file mode 100644
index 0000000..6c51be1
--- /dev/null
+++ b/value/src/test/java/com/google/auto/value/extension/toprettystring/ToPrettyStringValidatorTest.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.toprettystring;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+
+import com.google.auto.value.extension.toprettystring.processor.ToPrettyStringValidator;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ToPrettyStringValidatorTest {
+ @Test
+ public void cannotBeStatic() {
+ JavaFileObject file =
+ JavaFileObjects.forSourceLines(
+ "test.Test",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Test {",
+ " @ToPrettyString",
+ " static String toPretty() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ Compilation compilation = compile(file);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("must be instance methods")
+ .inFile(file)
+ .onLineContaining("static String toPretty()");
+ }
+
+ @Test
+ public void mustReturnString() {
+ JavaFileObject file =
+ JavaFileObjects.forSourceLines(
+ "test.Test",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Test {",
+ " @ToPrettyString",
+ " CharSequence toPretty() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ Compilation compilation = compile(file);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("must return String")
+ .inFile(file)
+ .onLineContaining("CharSequence toPretty()");
+ }
+
+ @Test
+ public void noParameters() {
+ JavaFileObject file =
+ JavaFileObjects.forSourceLines(
+ "test.Test",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Test {",
+ " @ToPrettyString",
+ " String toPretty(String value) {",
+ " return value;",
+ " }",
+ "}",
+ "");
+ Compilation compilation = compile(file);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("cannot have parameters")
+ .inFile(file)
+ .onLineContaining("String toPretty(String value)");
+ }
+
+ @Test
+ public void onlyOneToPrettyStringMethod_sameClass() {
+ JavaFileObject file =
+ JavaFileObjects.forSourceLines(
+ "test.Test",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Test {",
+ " @ToPrettyString",
+ " String toPretty1() {",
+ " return new String();",
+ " }",
+ "",
+ " @ToPrettyString",
+ " String toPretty2() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ Compilation compilation = compile(file);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ error(
+ "test.Test has multiple @ToPrettyString methods:",
+ " - test.Test.toPretty1()",
+ " - test.Test.toPretty2()"))
+ .inFile(file)
+ .onLineContaining("class Test");
+ }
+
+ @Test
+ public void onlyOneToPrettyStringMethod_superclass() {
+ JavaFileObject superclass =
+ JavaFileObjects.forSourceLines(
+ "test.Superclass",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Superclass {",
+ " @ToPrettyString",
+ " String toPretty1() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ JavaFileObject subclass =
+ JavaFileObjects.forSourceLines(
+ "test.Subclass",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Subclass extends Superclass {",
+ " @ToPrettyString",
+ " String toPretty2() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ Compilation compilation = compile(superclass, subclass);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ error(
+ "test.Subclass has multiple @ToPrettyString methods:",
+ " - test.Superclass.toPretty1()",
+ " - test.Subclass.toPretty2()"))
+ .inFile(subclass)
+ .onLineContaining("class Subclass");
+ }
+
+ @Test
+ public void onlyOneToPrettyStringMethod_superinterface() {
+ JavaFileObject superinterface =
+ JavaFileObjects.forSourceLines(
+ "test.Superinterface",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "interface Superinterface {",
+ " @ToPrettyString",
+ " default String toPretty1() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ JavaFileObject subclass =
+ JavaFileObjects.forSourceLines(
+ "test.Subclass",
+ "package test;",
+ "",
+ "import com.google.auto.value.extension.toprettystring.ToPrettyString;",
+ "",
+ "class Subclass implements Superinterface {",
+ " @ToPrettyString",
+ " String toPretty2() {",
+ " return new String();",
+ " }",
+ "}",
+ "");
+ Compilation compilation = compile(superinterface, subclass);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ error(
+ "test.Subclass has multiple @ToPrettyString methods:",
+ " - test.Superinterface.toPretty1()",
+ " - test.Subclass.toPretty2()"))
+ .inFile(subclass)
+ .onLineContaining("class Subclass");
+ }
+
+ private static Compilation compile(JavaFileObject... javaFileObjects) {
+ return javac().withProcessors(new ToPrettyStringValidator()).compile(javaFileObjects);
+ }
+
+ private static String error(String... lines) {
+ return String.join("\n ", lines);
+ }
+}
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java
index b8a36ea..1f79a07 100644
--- a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationCompilationTest.java
@@ -74,11 +74,13 @@
"",
"import com.example.annotations.MyAnnotation;",
"import com.example.enums.MyEnum;",
+ "import java.io.Serializable;",
GeneratedImport.importGeneratedAnnotationType(),
"",
"@Generated(\"" + AutoAnnotationProcessor.class.getName() + "\")",
"final class AutoAnnotation_AnnotationFactory_newMyAnnotation",
- " implements MyAnnotation {",
+ " implements MyAnnotation, Serializable {",
+ " private static final long serialVersionUID = -7473814294717163169L;",
" private final MyEnum value;",
" private static final int defaultedValue = 23;",
"",
@@ -129,6 +131,7 @@
Compilation compilation =
javac()
.withProcessors(new AutoAnnotationProcessor())
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
.compile(annotationFactoryJavaFile, myAnnotationJavaFile, myEnumJavaFile);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -157,11 +160,13 @@
JavaFileObject expectedOutput =
JavaFileObjects.forSourceLines(
"AutoAnnotation_AnnotationFactory_newMyAnnotation",
+ "import java.io.Serializable;",
GeneratedImport.importGeneratedAnnotationType(),
"",
"@Generated(\"" + AutoAnnotationProcessor.class.getName() + "\")",
"final class AutoAnnotation_AnnotationFactory_newMyAnnotation",
- " implements MyAnnotation {",
+ " implements MyAnnotation, Serializable {",
+ " private static final long serialVersionUID = 0L;",
" AutoAnnotation_AnnotationFactory_newMyAnnotation() {",
" }",
"",
@@ -191,6 +196,7 @@
Compilation compilation =
javac()
.withProcessors(new AutoAnnotationProcessor())
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
.compile(annotationFactoryJavaFile, myAnnotationJavaFile);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -237,12 +243,14 @@
"package com.example.factories;",
"",
"import com.example.annotations.MyAnnotation;",
+ "import java.io.Serializable",
"import java.util.Arrays;",
GeneratedImport.importGeneratedAnnotationType(),
"",
"@Generated(\"" + AutoAnnotationProcessor.class.getName() + "\")",
- "final class AutoAnnotation_AnnotationFactory_newMyAnnotation implements MyAnnotation"
- + " {",
+ "final class AutoAnnotation_AnnotationFactory_newMyAnnotation implements MyAnnotation,"
+ + " Serializable {",
+ " private static final long serialVersionUID = -8116050813861599066L;",
" private final int[] value;",
"",
" AutoAnnotation_AnnotationFactory_newMyAnnotation(int[] value) {",
@@ -288,6 +296,7 @@
Compilation compilation =
javac()
.withProcessors(new AutoAnnotationProcessor())
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
.compile(annotationFactoryJavaFile, myAnnotationJavaFile, gwtCompatibleJavaFile);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -343,6 +352,7 @@
"",
"import com.example.annotations.MyAnnotation;",
"import com.example.enums.MyEnum;",
+ "import java.io.Serializable;",
"import java.util.Arrays;",
"import java.util.Collection;",
"import java.util.List;",
@@ -350,8 +360,9 @@
GeneratedImport.importGeneratedAnnotationType(),
"",
"@Generated(\"" + AutoAnnotationProcessor.class.getName() + "\")",
- "final class AutoAnnotation_AnnotationFactory_newMyAnnotation implements MyAnnotation"
- + " {",
+ "final class AutoAnnotation_AnnotationFactory_newMyAnnotation implements MyAnnotation,"
+ + " Serializable {",
+ " private static final long serialVersionUID = -2102364343628921304L;",
" private final int[] value;",
" private final MyEnum[] enums;",
"",
@@ -426,6 +437,7 @@
Compilation compilation =
javac()
.withProcessors(new AutoAnnotationProcessor())
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
.compile(annotationFactoryJavaFile, myEnumJavaFile, myAnnotationJavaFile);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -457,9 +469,7 @@
" @NotAutoAnnotation Empty notNewEmpty() {}",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(erroneousJavaFileObject);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(erroneousJavaFileObject);
assertThat(compilation)
.hadErrorContaining("NotAutoAnnotation")
.inFile(erroneousJavaFileObject)
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java
index 55a4c5d..094b570 100644
--- a/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/AutoAnnotationErrorsTest.java
@@ -57,9 +57,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation).succeededWithoutWarnings();
}
@@ -79,9 +77,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining("must be static")
.inFile(testSource)
@@ -103,9 +99,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining("must be an annotation type, not java.lang.String")
.inFile(testSource)
@@ -132,9 +126,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining("@AutoAnnotation methods cannot be overloaded")
.inFile(testSource)
@@ -196,9 +188,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining("method parameter 'fred' must have the same name")
.inFile(testSource)
@@ -221,9 +211,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining(
"method parameter 'value' has type java.lang.String "
@@ -267,9 +255,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(testSource, testAnnotation);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(testSource, testAnnotation);
assertThat(compilation)
.hadErrorContaining(
"method parameter 'value' has type "
@@ -296,9 +282,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining(
"method parameter 'other' must have the same name as a member of "
@@ -323,9 +307,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(TEST_ANNOTATION, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(TEST_ANNOTATION, testSource);
assertThat(compilation)
.hadErrorContaining("method needs a parameter with name 'value' and type int")
.inFile(testSource)
@@ -357,9 +339,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(annotationSource, testSource);
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(annotationSource, testSource);
assertThat(compilation)
.hadErrorContaining(
"@AutoAnnotation cannot yet supply a default value for annotation-valued member "
@@ -399,10 +379,7 @@
" }",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoAnnotationProcessor())
- .compile(annotationSource, testSource);
- assertThat(compilation)
- .hadErrorContaining("variable value$ is already defined in constructor");
+ javac().withProcessors(new AutoAnnotationProcessor()).compile(annotationSource, testSource);
+ assertThat(compilation).hadErrorContaining("variable value$ is already defined in constructor");
}
}
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoBuilderCompilationTest.java b/value/src/test/java/com/google/auto/value/processor/AutoBuilderCompilationTest.java
new file mode 100644
index 0000000..50b6b27
--- /dev/null
+++ b/value/src/test/java/com/google/auto/value/processor/AutoBuilderCompilationTest.java
@@ -0,0 +1,875 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.TruthJUnit.assume;
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AutoBuilderCompilationTest {
+ private static final JavaFileObject EXPECTED_SIMPLE_OUTPUT =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.AutoBuilder_Baz_Builder",
+ "package foo.bar;",
+ "",
+ GeneratedImport.importGeneratedAnnotationType(),
+ "",
+ "@Generated(\"" + AutoBuilderProcessor.class.getName() + "\")",
+ "class AutoBuilder_Baz_Builder implements Baz.Builder {",
+ " private Integer anInt;",
+ " private String aString;",
+ "",
+ " AutoBuilder_Baz_Builder() {}",
+ "",
+ " @Override public Baz.Builder setAnInt(int anInt) {",
+ " this.anInt = anInt;",
+ " return this;",
+ " }",
+ "",
+ " @Override public Baz.Builder setAString(String aString) {",
+ " if (aString == null) {",
+ " throw new NullPointerException(\"Null aString\");",
+ " }",
+ " this.aString = aString;",
+ " return this;",
+ " }",
+ "",
+ " @Override",
+ " public Baz build() {",
+ " if (this.anInt == null",
+ " || this.aString == null) {",
+ " StringBuilder missing = new StringBuilder();",
+ " if (this.anInt == null) {",
+ " missing.append(\" anInt\");",
+ " }",
+ " if (this.aString == null) {",
+ " missing.append(\" aString\");",
+ " }",
+ " throw new IllegalStateException(\"Missing required properties:\" + missing);",
+ " }",
+ " return new Baz(",
+ " this.anInt,",
+ " this.aString);",
+ " }",
+ "}");
+
+ @Test
+ public void simpleSuccess() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " private final int anInt;",
+ " private final String aString;",
+ "",
+ " public Baz(int anInt, String aString) {",
+ " this.anInt = anInt;",
+ " this.aString = aString;",
+ " }",
+ "",
+ " public int anInt() {",
+ " return anInt;",
+ " }",
+ "",
+ " public String aString() {",
+ " return aString;",
+ " }",
+ "",
+ " public static Builder builder() {",
+ " return new AutoBuilder_Baz_Builder();",
+ " }",
+ "",
+ " @AutoBuilder",
+ " public interface Builder {",
+ " Builder setAnInt(int x);",
+ " Builder setAString(String x);",
+ " Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation)
+ .generatedSourceFile("foo.bar.AutoBuilder_Baz_Builder")
+ .hasSourceEquivalentTo(EXPECTED_SIMPLE_OUTPUT);
+ }
+
+ @Test
+ public void simpleRecord() {
+ double version = Double.parseDouble(JAVA_SPECIFICATION_VERSION.value());
+ assume().that(version).isAtLeast(16.0);
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public record Baz(int anInt, String aString) {",
+ " public static Builder builder() {",
+ " return new AutoBuilder_Baz_Builder();",
+ " }",
+ "",
+ " @AutoBuilder",
+ " public interface Builder {",
+ " Builder setAnInt(int x);",
+ " Builder setAString(String x);",
+ " Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation)
+ .generatedSourceFile("foo.bar.AutoBuilder_Baz_Builder")
+ .hasSourceEquivalentTo(EXPECTED_SIMPLE_OUTPUT);
+ }
+
+ @Test
+ public void buildOtherPackage() {
+ JavaFileObject built =
+ JavaFileObjects.forSourceLines(
+ "com.example.Built",
+ "package com.example;",
+ "",
+ "public class Built {",
+ " private final int anInt;",
+ " private final String aString;",
+ "",
+ " public Built(int anInt, String aString) {",
+ " this.anInt = anInt;",
+ " this.aString = aString;",
+ " }",
+ "}");
+ JavaFileObject builder =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Builder",
+ "package foo.bar;",
+ "",
+ "import com.example.Built;",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "@AutoBuilder(ofClass = Built.class)",
+ "public interface Builder {",
+ " public static Builder builder() {",
+ " return new AutoBuilder_Builder();",
+ " }",
+ "",
+ " Builder setAnInt(int x);",
+ " Builder setAString(String x);",
+ " Built build();",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(built, builder);
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation).generatedSourceFile("foo.bar.AutoBuilder_Builder");
+ }
+
+ @Test
+ public void autoBuilderOnEnum() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "@AutoBuilder",
+ "public enum Baz {",
+ " ZIG, ZAG, DUSTIN,",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderWrongType] @AutoBuilder only applies to classes and interfaces")
+ .inFile(javaFileObject)
+ .onLineContaining("enum Baz");
+ }
+
+ @Test
+ public void autoBuilderPrivate() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " @AutoBuilder",
+ " private interface Builder {",
+ " Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("[AutoBuilderPrivate] @AutoBuilder class must not be private")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void autoBuilderNestedInPrivate() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " private static class Private {",
+ " @AutoBuilder",
+ " public interface Builder {",
+ " Baz build();",
+ " }",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderInPrivate] @AutoBuilder class must not be nested in a private class")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void autoBuilderInner() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " @AutoBuilder",
+ " abstract class Builder {",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("[AutoBuilderInner] Nested @AutoBuilder class must be static")
+ .inFile(javaFileObject)
+ .onLineContaining("class Builder");
+ }
+
+ @Test
+ public void innerConstructor() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " class Inner {}",
+ "",
+ " @AutoBuilder(ofClass = Inner.class)",
+ " interface Builder {",
+ " abstract Inner build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("[AutoBuilderInner] Nested @AutoBuilder ofClass class must be static")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void noVisibleConstructor() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " @AutoBuilder(ofClass = System.class)",
+ " interface Builder {",
+ " abstract System build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("[AutoBuilderNoVisible] No visible constructor for java.lang.System")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void noVisibleMethod() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " private static Baz of() {",
+ " return new Baz();",
+ " }",
+ "",
+ " @AutoBuilder(callMethod = \"of\")",
+ " interface Builder {",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderNoVisible] No visible static method named \"of\" for foo.bar.Baz")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void methodNotStatic() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " Baz of() {",
+ " return this;",
+ " }",
+ "",
+ " @AutoBuilder(callMethod = \"of\")",
+ " interface Builder {",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderNoVisible] No visible static method named \"of\" for foo.bar.Baz")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void noMatchingConstructor() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " public Baz(int notMe) {}",
+ "",
+ " public Baz(String notMeEither) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " Builder setBuh(String x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderNoMatch] Property names do not correspond to the parameter names of any"
+ + " constructor:\n"
+ + " Baz(int notMe)\n"
+ + " Baz(java.lang.String notMeEither)")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void twoMatchingConstructors() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public class Baz {",
+ " public Baz() {}",
+ "",
+ " public Baz(int buh) {}",
+ "",
+ " public Baz(String buh) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " Builder setBuh(String x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderAmbiguous] Property names correspond to more than one constructor:\n"
+ + " Baz(int buh)\n"
+ + " Baz(java.lang.String buh)")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void constructInterface() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "public interface Baz {",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderEnclosing] @AutoBuilder must specify ofClass=Something.class or it must"
+ + " be nested inside the class to be built; actually nested inside interface"
+ + " foo.bar.Baz")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void inconsistentSetPrefix() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int one, int two) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder one(int x);",
+ " abstract Builder setTwo(int x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderSetNotSet] If any setter methods use the setFoo convention then all must")
+ .inFile(javaFileObject)
+ .onLineContaining("Builder one(int x)");
+ }
+
+ @Test
+ public void missingSetter() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int one, int two) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder one(int x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderBuilderMissingMethod] Expected a method with this signature:"
+ + " foo.bar.Baz.Builder two(int), or a twoBuilder() method")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder");
+ }
+
+ @Test
+ public void tooManyArgs() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int one, int two) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder one(int x);",
+ " abstract Builder two(int x);",
+ " abstract Builder many(int x, int y);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("[AutoBuilderBuilderArgs] Builder methods must have 0 or 1 parameters")
+ .inFile(javaFileObject)
+ .onLineContaining("many(int x, int y)");
+ }
+
+ @Test
+ public void alienNoArgMethod() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int one, int two) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder one(int x);",
+ " abstract Builder two(int x);",
+ " abstract String alien();",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderBuilderNoArg] Method without arguments should be a build method returning"
+ + " foo.bar.Baz, or a getter method with the same name and type as a parameter of"
+ + " Baz(int one, int two), or fooBuilder() where foo is a parameter of Baz(int"
+ + " one, int two)")
+ .inFile(javaFileObject)
+ .onLineContaining("String alien()");
+ }
+
+ @Test
+ public void alienOneArgMethod() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int one, int two) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder one(int x);",
+ " abstract Builder two(int x);",
+ " abstract Builder three(int x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderBuilderWhatProp] Method three does not correspond to "
+ + "a parameter of Baz(int one, int two)")
+ .inFile(javaFileObject)
+ .onLineContaining("three(int x)");
+ }
+
+ @Test
+ public void setterReturnType() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int one, int two) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder one(int x);",
+ " abstract void two(int x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderBuilderRet] Setter methods must return foo.bar.Baz.Builder")
+ .inFile(javaFileObject)
+ .onLineContaining("two(int x)");
+ }
+
+ @Test
+ public void nullableSetterForNonNullableParameter() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "import org.checkerframework.checker.nullness.qual.Nullable;",
+ "",
+ "class Baz {",
+ " Baz(String thing) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder thing(@Nullable String x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ JavaFileObject nullableFileObject =
+ JavaFileObjects.forSourceLines(
+ "org.checkerframework.checker.nullness.qual.Nullable",
+ "package org.jspecify.nullness;",
+ "",
+ "import java.lang.annotation.ElementType;",
+ "import java.lang.annotation.Target;",
+ "",
+ "@Target(ElementType.TYPE_USE)",
+ "public @interface Nullable {}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject, nullableFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderNullNotNull] Parameter of setter method is @Nullable but parameter"
+ + " \"thing\" of Baz(java.lang.String thing) is not")
+ .inFile(javaFileObject)
+ .onLineContaining("thing(@Nullable String x)");
+ }
+
+ @Test
+ public void setterWrongType() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "",
+ "class Baz {",
+ " Baz(int up, int down) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder up(int x);",
+ " abstract Builder down(String x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderGetVsSet] Parameter type java.lang.String of setter method should be int"
+ + " to match parameter \"down\" of Baz(int up, int down)")
+ .inFile(javaFileObject)
+ .onLineContaining("down(String x)");
+ }
+
+ @Test
+ public void setterWrongTypeEvenWithConversion() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "import java.util.Optional;",
+ "",
+ "class Baz {",
+ " Baz(Optional<String> maybe) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder {",
+ " abstract Builder maybe(int x);",
+ " abstract Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderGetVsSetOrConvert] Parameter type int of setter method should be"
+ + " java.util.Optional<java.lang.String> to match parameter \"maybe\" of"
+ + " Baz(java.util.Optional<java.lang.String> maybe), or it should be a type that"
+ + " can be passed to Optional.of to produce java.util.Optional<java.lang.String>")
+ .inFile(javaFileObject)
+ .onLineContaining("maybe(int x)");
+ }
+
+ @Test
+ public void typeParamMismatch() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoBuilder;",
+ "import java.util.Optional;",
+ "",
+ "class Baz<T> {",
+ " Baz(T param) {}",
+ "",
+ " @AutoBuilder",
+ " interface Builder<E> {",
+ " abstract Builder<E> param(E param);",
+ " abstract Baz<E> build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoBuilderProcessor())
+ .withOptions("-Acom.google.auto.value.AutoBuilderIsUnstable")
+ .compile(javaFileObject);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[AutoBuilderTypeParams] Builder type parameters <E> must match type parameters <T> of"
+ + " Baz(T param)")
+ .inFile(javaFileObject)
+ .onLineContaining("interface Builder<E>");
+ }
+}
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoOneOfCompilationTest.java b/value/src/test/java/com/google/auto/value/processor/AutoOneOfCompilationTest.java
index 63e8419..788b543 100644
--- a/value/src/test/java/com/google/auto/value/processor/AutoOneOfCompilationTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/AutoOneOfCompilationTest.java
@@ -43,7 +43,9 @@
"import java.io.Serializable;",
"",
"@AutoOneOf(TaskResult.Kind.class)",
- "public abstract class TaskResult<V, T extends Throwable> {",
+ "public abstract class TaskResult<V, T extends Throwable> implements Serializable {",
+ " private static final long serialVersionUID = 1234L;",
+ "",
" public enum Kind {VALUE, EXCEPTION, EMPTY}",
" public abstract Kind getKind();",
"",
@@ -92,6 +94,8 @@
" // Parent class that each implementation will inherit from.",
" private abstract static class Parent_<V, T extends Throwable> "
+ "extends TaskResult<V, T> {",
+ " private static final long serialVersionUID = 1234L;",
+ "",
" @Override",
" public V value() {",
" throw new UnsupportedOperationException(getKind().toString());",
@@ -111,6 +115,8 @@
" // Implementation when the contained property is \"value\".",
" private static final class Impl_value<V, T extends Throwable> "
+ "extends Parent_<V, T> {",
+ " private static final long serialVersionUID = 1234L;",
+ "",
" private final V value;",
"",
" Impl_value(V value) {",
@@ -152,6 +158,8 @@
" // Implementation when the contained property is \"exception\".",
" private static final class Impl_exception<V, T extends Throwable> "
+ "extends Parent_<V, T> {",
+ " private static final long serialVersionUID = 1234L;",
+ "",
" private final Throwable exception;",
"",
" Impl_exception(Throwable exception) {",
@@ -193,6 +201,8 @@
" // Implementation when the contained property is \"empty\".",
" private static final class Impl_empty<V, T extends Throwable> "
+ "extends Parent_<V, T> {",
+ " private static final long serialVersionUID = 1234L;",
+ "",
" static final Impl_empty<?, ?> INSTANCE = new Impl_empty<>();",
"",
" private Impl_empty() {}",
@@ -200,6 +210,10 @@
" @Override",
" public void empty() {}",
"",
+ " private Object readResolve() {",
+ " return INSTANCE;",
+ " }",
+ "",
" @Override",
" public String toString() {",
" return \"TaskResult{empty}\";",
@@ -223,7 +237,8 @@
Compilation compilation =
javac()
.withProcessors(new AutoOneOfProcessor())
- .withOptions("-Xlint:-processing", "-implicit:none")
+ .withOptions(
+ "-Xlint:-processing", "-implicit:none", "-A" + Nullables.NULLABLE_OPTION + "=")
.compile(javaFileObject);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -307,7 +322,8 @@
Compilation compilation =
javac()
.withProcessors(new AutoOneOfProcessor())
- .withOptions("-Xlint:-processing", "-implicit:none")
+ .withOptions(
+ "-Xlint:-processing", "-implicit:none", "-A" + Nullables.NULLABLE_OPTION + "=")
.compile(javaFileObject);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
diff --git a/value/src/test/java/com/google/auto/value/processor/AutoValueCompilationTest.java b/value/src/test/java/com/google/auto/value/processor/AutoValueCompilationTest.java
index e46c9f5..ab6690f 100644
--- a/value/src/test/java/com/google/auto/value/processor/AutoValueCompilationTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/AutoValueCompilationTest.java
@@ -57,8 +57,8 @@
public void simpleSuccess() {
// Positive test case that ensures we generate the expected code for at least one case.
// Most AutoValue code-generation tests are functional, meaning that we check that the generated
- // code does the right thing rather than checking what it looks like, but this test is a sanity
- // check that we are not generating correct but weird code.
+ // code does the right thing rather than checking what it looks like, but this test checks that
+ // we are not generating correct but weird code.
JavaFileObject javaFileObject =
JavaFileObjects.forSourceLines(
"foo.bar.Baz",
@@ -118,7 +118,10 @@
" }",
"}");
Compilation compilation =
- javac().withProcessors(new AutoValueProcessor()).compile(javaFileObject);
+ javac()
+ .withProcessors(new AutoValueProcessor())
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
+ .compile(javaFileObject);
assertThat(compilation)
.generatedSourceFile("foo.bar.AutoValue_Baz")
.hasSourceEquivalentTo(expectedOutput);
@@ -216,7 +219,10 @@
" }",
"}");
Compilation compilation =
- javac().withProcessors(new AutoValueProcessor()).compile(javaFileObject);
+ javac()
+ .withProcessors(new AutoValueProcessor())
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
+ .compile(javaFileObject);
assertThat(compilation)
.generatedSourceFile("foo.bar.AutoValue_Baz")
.hasSourceEquivalentTo(expectedOutput);
@@ -335,7 +341,6 @@
" return false;",
" }",
"",
-
" @Override",
" public int hashCode() {",
" int h$ = 1;",
@@ -348,7 +353,8 @@
Compilation compilation =
javac()
.withProcessors(new AutoValueProcessor())
- .withOptions("-Xlint:-processing", "-implicit:none")
+ .withOptions(
+ "-Xlint:-processing", "-implicit:none", "-A" + Nullables.NULLABLE_OPTION + "=")
.compile(annotFileObject, outerFileObject, nestyFileObject);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -1129,10 +1135,10 @@
" return this.anInt == that.anInt()",
" && Arrays.equals(this.aByteArray, "
+ "(that instanceof AutoValue_Baz) "
- + "? ((AutoValue_Baz) that).aByteArray : that.aByteArray())",
+ + "? ((AutoValue_Baz<?>) that).aByteArray : that.aByteArray())",
" && Arrays.equals(this.aNullableIntArray, "
+ "(that instanceof AutoValue_Baz) "
- + "? ((AutoValue_Baz) that).aNullableIntArray : that.aNullableIntArray())",
+ + "? ((AutoValue_Baz<?>) that).aNullableIntArray : that.aNullableIntArray())",
" && this.aList.equals(that.aList())",
" && this.anImmutableList.equals(that.anImmutableList())",
" && this.anOptionalString.equals(that.anOptionalString())",
@@ -1312,17 +1318,19 @@
+ "NestedAutoValue.builder();",
" this.aNestedAutoValue = aNestedAutoValue$builder.build();",
" }",
- " String missing = \"\";",
- " if (this.anInt == null) {",
- " missing += \" anInt\";",
- " }",
- " if (this.aByteArray == null) {",
- " missing += \" aByteArray\";",
- " }",
- " if (this.aList == null) {",
- " missing += \" aList\";",
- " }",
- " if (!missing.isEmpty()) {",
+ " if (this.anInt == null",
+ " || this.aByteArray == null",
+ " || this.aList == null) {",
+ " StringBuilder missing = new StringBuilder();",
+ " if (this.anInt == null) {",
+ " missing.append(\" anInt\");",
+ " }",
+ " if (this.aByteArray == null) {",
+ " missing.append(\" aByteArray\");",
+ " }",
+ " if (this.aList == null) {",
+ " missing.append(\" aList\");",
+ " }",
" throw new IllegalStateException(\"Missing required properties:\" + missing);",
" }",
" return new AutoValue_Baz<T>(",
@@ -1339,7 +1347,8 @@
Compilation compilation =
javac()
.withProcessors(new AutoValueProcessor())
- .withOptions("-Xlint:-processing", "-implicit:none")
+ .withOptions(
+ "-Xlint:-processing", "-implicit:none", "-A" + Nullables.NULLABLE_OPTION + "=")
.compile(javaFileObject, nestedJavaFileObject);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -1587,7 +1596,7 @@
assertThat(compilation)
.hadErrorContaining(
"Parameter type java.lang.String of setter method should be int "
- + "to match getter foo.bar.Baz.blim")
+ + "to match property method foo.bar.Baz.blim()")
.inFile(javaFileObject)
.onLineContaining("Builder blim(String x)");
}
@@ -1620,10 +1629,10 @@
.compile(javaFileObject);
assertThat(compilation)
.hadErrorContaining(
- "Parameter type java.lang.String of setter method should be "
- + "com.google.common.collect.ImmutableList<java.lang.String> to match getter "
- + "foo.bar.Baz.blam, or it should be a type that can be passed to "
- + "ImmutableList.copyOf")
+ "Parameter type java.lang.String of setter method should be"
+ + " com.google.common.collect.ImmutableList<java.lang.String> to match property"
+ + " method foo.bar.Baz.blam(), or it should be a type that can be passed to"
+ + " ImmutableList.copyOf")
.inFile(javaFileObject)
.onLineContaining("Builder blam(String x)");
}
@@ -1657,11 +1666,11 @@
.compile(javaFileObject);
assertThat(compilation)
.hadErrorContaining(
- "Parameter type java.util.Collection<java.lang.Integer> of setter method should be "
- + "com.google.common.collect.ImmutableList<java.lang.String> to match getter "
- + "foo.bar.Baz.blam, or it should be a type that can be passed to "
- + "ImmutableList.copyOf to produce "
- + "com.google.common.collect.ImmutableList<java.lang.String>")
+ "Parameter type java.util.Collection<java.lang.Integer> of setter method should be"
+ + " com.google.common.collect.ImmutableList<java.lang.String> to match property"
+ + " method foo.bar.Baz.blam(), or it should be a type that can be passed to"
+ + " ImmutableList.copyOf to produce"
+ + " com.google.common.collect.ImmutableList<java.lang.String>")
.inFile(javaFileObject)
.onLineContaining("Builder blam(Collection<Integer> x)");
}
@@ -1694,7 +1703,7 @@
assertThat(compilation)
.hadErrorContaining(
"Parameter type java.lang.String of setter method should be int "
- + "to match getter foo.bar.Baz.getBlim")
+ + "to match property method foo.bar.Baz.getBlim()")
.inFile(javaFileObject)
.onLineContaining("Builder blim(String x)");
}
@@ -1768,7 +1777,8 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining("Method does not correspond to a property of foo.bar.Item")
+ .hadErrorContaining(
+ "Method setTitle does not correspond to a property method of foo.bar.Item")
.inFile(javaFileObject)
.onLineContaining("Builder setTitle(String title)");
assertThat(compilation)
@@ -1802,7 +1812,7 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining("Method does not correspond to a property of foo.bar.Baz")
+ .hadErrorContaining("Method blim does not correspond to a property method of foo.bar.Baz")
.inFile(javaFileObject)
.onLineContaining("Builder blim(int x)");
}
@@ -1839,6 +1849,35 @@
}
@Test
+ public void autoValueBuilderSetterReturnType() {
+ JavaFileObject javaFileObject =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "",
+ "@AutoValue",
+ "public abstract class Baz {",
+ " abstract int blim();",
+ "",
+ " @AutoValue.Builder",
+ " public interface Builder {",
+ " void blim(int x);",
+ " Baz build();",
+ " }",
+ "}");
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
+ .compile(javaFileObject);
+ assertThat(compilation)
+ .hadErrorContaining("Setter methods must return foo.bar.Baz.Builder")
+ .inFile(javaFileObject)
+ .onLineContaining("void blim(int x)");
+ }
+
+ @Test
public void autoValueBuilderWrongTypeGetter() {
JavaFileObject javaFileObject =
JavaFileObjects.forSourceLines(
@@ -1866,10 +1905,15 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining(
- "Method matches a property of foo.bar.Baz but has return type T instead of U")
+ .hadErrorContainingMatch(
+ "Method matches a property of foo\\.bar\\.Baz<T, ?U> but has return type T instead of"
+ + " U")
.inFile(javaFileObject)
.onLineContaining("T blam()");
+ // The <T, ?U> is because we're depending on TypeMirror.toString(), and the JDK actually spells
+ // this as <T,U> with no space. While it's not completely sound to expect a given string from
+ // TypeMirror.toString(), in practice it's hard to imagine that it would be anything other
+ // than "foo.bar.Baz<T,U>" or "foo.bar.Baz<T, U>" given the specification.
}
@Test
@@ -1929,9 +1973,9 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining("Property strings has a property builder so it cannot be @Nullable")
+ .hadErrorContaining("Property strings is @Nullable so it cannot have a property builder")
.inFile(javaFileObject)
- .onLineContaining("@Nullable ImmutableList<String> strings()");
+ .onLineContaining("stringsBuilder()");
}
@Test
@@ -1963,9 +2007,9 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining("Property strings has a property builder so it cannot be @Nullable")
+ .hadErrorContaining("Property strings is @Nullable so it cannot have a property builder")
.inFile(javaFileObject)
- .onLineContaining("@Nullable ImmutableList<String> strings()");
+ .onLineContaining("stringsBuilder()");
}
@Test
@@ -2451,8 +2495,8 @@
assertThat(compilation)
.hadErrorContaining(
"Method without arguments should be a build method returning foo.bar.Baz, or a getter"
- + " method with the same name and type as a getter method of foo.bar.Baz, or"
- + " fooBuilder() where foo() or getFoo() is a getter method of foo.bar.Baz")
+ + " method with the same name and type as a property method of foo.bar.Baz, or"
+ + " fooBuilder() where foo() or getFoo() is a property method of foo.bar.Baz")
.inFile(javaFileObject)
.onLineContaining("Builder whut()");
}
@@ -2481,7 +2525,7 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining("Method does not correspond to a property of foo.bar.Baz")
+ .hadErrorContaining("Method whut does not correspond to a property method of foo.bar.Baz")
.inFile(javaFileObject)
.onLineContaining("void whut(String x)");
}
@@ -2539,7 +2583,8 @@
.compile(javaFileObject);
assertThat(compilation)
.hadErrorContaining(
- "Builder must have a single no-argument method returning foo.bar.Baz<T>")
+ "Builder must have a single no-argument method, typically called build(), that returns"
+ + " foo.bar.Baz<T>")
.inFile(javaFileObject)
.onLineContaining("public interface Builder<T>");
}
@@ -2569,11 +2614,15 @@
.withProcessors(new AutoValueProcessor(), new AutoValueBuilderProcessor())
.compile(javaFileObject);
assertThat(compilation)
- .hadErrorContaining("Builder must have a single no-argument method returning foo.bar.Baz")
+ .hadErrorContaining(
+ "Builder must have a single no-argument method, typically called build(), that returns"
+ + " foo.bar.Baz")
.inFile(javaFileObject)
.onLineContaining("Baz build()");
assertThat(compilation)
- .hadErrorContaining("Builder must have a single no-argument method returning foo.bar.Baz")
+ .hadErrorContaining(
+ "Builder must have a single no-argument method, typically called build(), that returns"
+ + " foo.bar.Baz")
.inFile(javaFileObject)
.onLineContaining("Baz create()");
}
@@ -3286,7 +3335,7 @@
"}");
private static final String GENERATED_PROPERTY_TYPE =
String.join(
- "\n",
+ "\n", //
"package foo.baz;",
"",
"public class GeneratedPropertyType {}");
@@ -3315,18 +3364,14 @@
GENERATED_TYPES.forEach(
(typeName, source) -> {
try {
- JavaFileObject generated =
- processingEnv
- .getFiler()
- .createSourceFile(typeName);
+ JavaFileObject generated = processingEnv.getFiler().createSourceFile(typeName);
try (Writer writer = generated.openWriter()) {
writer.write(source);
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
- }
- );
+ });
}
return false;
}
@@ -3337,7 +3382,41 @@
}
}
+ // This is a regression test for the problem described in
+ // https://github.com/google/auto/issues/1087.
+ @Test
+ public void kotlinMetadataAnnotationsAreImplicitlyExcludedFromCopying() {
+ JavaFileObject metadata =
+ JavaFileObjects.forSourceLines(
+ "kotlin.Metadata", "package kotlin;", "", "public @interface Metadata {", "}");
+ JavaFileObject test =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Test",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "import kotlin.Metadata;",
+ "",
+ "@AutoValue.CopyAnnotations",
+ "@Metadata",
+ "@AutoValue",
+ "public abstract class Test {",
+ " public abstract String string();",
+ "}");
+ AutoValueProcessor autoValueProcessor = new AutoValueProcessor();
+ Compilation compilation =
+ javac()
+ .withProcessors(autoValueProcessor)
+ .withOptions("-Xlint:-processing", "-implicit:none")
+ .compile(test, metadata);
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("foo.bar.AutoValue_Test")
+ .contentsAsUtf8String()
+ .doesNotContain("kotlin.Metadata");
+ }
+
private String sorted(String... imports) {
- return Arrays.stream(imports).sorted().collect(joining("\n"));
- }
+ return Arrays.stream(imports).sorted().collect(joining("\n"));
+ }
}
diff --git a/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java b/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java
index ce9eeed..56eaad2 100644
--- a/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/ExtensionTest.java
@@ -172,6 +172,7 @@
Compilation compilation =
javac()
.withProcessors(new AutoValueProcessor(ImmutableList.of(new FooExtension())))
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
.compile(javaFileObject);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
@@ -250,9 +251,7 @@
" abstract String dizzle();",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoValueProcessor(ImmutableList.of(ext1, ext2)))
- .compile(impl);
+ javac().withProcessors(new AutoValueProcessor(ImmutableList.of(ext1, ext2))).compile(impl);
assertThat(compilation)
.hadErrorContaining("wants to consume a method that was already consumed")
.inFile(impl)
@@ -596,10 +595,9 @@
"}");
Compilation compilation =
javac()
- .withProcessors(new AutoValueProcessor(ImmutableList.of(new FooExtension())))
- .compile(javaFileObject);
- assertThat(compilation)
- .hadErrorContaining("writeToParcel");
+ .withProcessors(new AutoValueProcessor(ImmutableList.of(new FooExtension())))
+ .compile(javaFileObject);
+ assertThat(compilation).hadErrorContaining("writeToParcel");
assertThat(compilation)
.hadWarningContaining(
"Abstract method is neither a property getter nor a Builder converter, "
@@ -647,13 +645,12 @@
"public abstract class Baz {",
"}");
Compilation compilation =
- javac()
- .withProcessors(new AutoValueProcessor(badJarLoader))
- .compile(javaFileObject);
+ javac().withProcessors(new AutoValueProcessor(badJarLoader)).compile(javaFileObject);
assertThat(compilation).succeeded();
- assertThat(compilation).hadWarningContaining(
- "This may be due to a corrupt jar file in the compiler's classpath.\n "
- + ServiceConfigurationError.class.getName());
+ assertThat(compilation)
+ .hadWarningContaining(
+ "This may be due to a corrupt jar file in the compiler's classpath.\n "
+ + ServiceConfigurationError.class.getName());
assertThat(compilation).generatedSourceFile("foo.bar.AutoValue_Baz");
}
@@ -857,8 +854,12 @@
String sideClassName = "Side_" + context.autoValueClass().getSimpleName();
String sideClass =
"" //
- + "package " + context.packageName() + ";\n"
- + "class " + sideClassName + " {}\n";
+ + "package "
+ + context.packageName()
+ + ";\n"
+ + "class "
+ + sideClassName
+ + " {}\n";
Filer filer = context.processingEnvironment().getFiler();
try {
String sideClassFqName = context.packageName() + "." + sideClassName;
@@ -912,25 +913,27 @@
@Test
public void propertyTypes() {
- JavaFileObject parent = JavaFileObjects.forSourceLines(
- "foo.bar.Parent",
- "package foo.bar;",
- "",
- "import java.util.List;",
- "",
- "interface Parent<T> {",
- " T thing();",
- " List<T> list();",
- "}");
- JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
- "foo.bar.Baz",
- "package foo.bar;",
- "",
- "import com.google.auto.value.AutoValue;",
- "",
- "@AutoValue",
- "abstract class Baz implements Parent<String> {",
- "}");
+ JavaFileObject parent =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Parent",
+ "package foo.bar;",
+ "",
+ "import java.util.List;",
+ "",
+ "interface Parent<T> {",
+ " T thing();",
+ " List<T> list();",
+ "}");
+ JavaFileObject autoValueClass =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "",
+ "@AutoValue",
+ "abstract class Baz implements Parent<String> {",
+ "}");
ContextChecker checker =
context -> {
assertThat(context.builder()).isEmpty();
@@ -955,15 +958,16 @@
@Test
public void finalAutoValueClassName() {
- JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
- "foo.bar.Baz",
- "package foo.bar;",
- "",
- "import com.google.auto.value.AutoValue;",
- "",
- "@AutoValue",
- "abstract class Baz {",
- "}");
+ JavaFileObject autoValueClass =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "",
+ "@AutoValue",
+ "abstract class Baz {",
+ "}");
ContextChecker checker =
context -> {
assertThat(context.finalAutoValueClassName()).isEqualTo("foo.bar.AutoValue_Baz");
@@ -982,43 +986,45 @@
@Test
public void builderContext() {
- JavaFileObject parent = JavaFileObjects.forSourceLines(
- "foo.bar.Parent",
- "package foo.bar;",
- "",
- "import com.google.common.collect.ImmutableList;",
- "",
- "interface Parent<T> {",
- " T thing();",
- " ImmutableList<T> list();",
- "}");
- JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
- "foo.bar.Baz",
- "package foo.bar;",
- "",
- "import com.google.auto.value.AutoValue;",
- "import com.google.common.collect.ImmutableList;",
- "",
- "@AutoValue",
- "abstract class Baz implements Parent<String> {",
- " static Builder builder() {",
- " return new AutoValue_Baz.Builder();",
- " }",
- "",
- " abstract Builder toBuilder();",
- "",
- " @AutoValue.Builder",
- " abstract static class Builder {",
- " abstract Builder setThing(String x);",
- " abstract Builder setList(Iterable<String> x);",
- " abstract Builder setList(ImmutableList<String> x);",
- " abstract ImmutableList.Builder<String> listBuilder();",
- " abstract Baz autoBuild();",
- " Baz build() {",
- " return autoBuild();",
- " }",
- " }",
- "}");
+ JavaFileObject parent =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Parent",
+ "package foo.bar;",
+ "",
+ "import com.google.common.collect.ImmutableList;",
+ "",
+ "interface Parent<T> {",
+ " T thing();",
+ " ImmutableList<T> list();",
+ "}");
+ JavaFileObject autoValueClass =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "import com.google.common.collect.ImmutableList;",
+ "",
+ "@AutoValue",
+ "abstract class Baz implements Parent<String> {",
+ " static Builder builder() {",
+ " return new AutoValue_Baz.Builder();",
+ " }",
+ "",
+ " abstract Builder toBuilder();",
+ "",
+ " @AutoValue.Builder",
+ " abstract static class Builder {",
+ " abstract Builder setThing(String x);",
+ " abstract Builder setList(Iterable<String> x);",
+ " abstract Builder setList(ImmutableList<String> x);",
+ " abstract ImmutableList.Builder<String> listBuilder();",
+ " abstract Baz autoBuild();",
+ " Baz build() {",
+ " return autoBuild();",
+ " }",
+ " }",
+ "}");
ContextChecker checker =
context -> {
assertThat(context.builder()).isPresent();
@@ -1075,27 +1081,102 @@
}
@Test
+ public void builderContextWithInheritance() {
+ JavaFileObject parent =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Parent",
+ "package foo.bar;",
+ "",
+ "interface Parent<BuilderT> {",
+ " BuilderT toBuilder();",
+ " interface Builder<T, BuilderT, BuiltT> {",
+ " BuilderT setThing(T x);",
+ " BuiltT build();",
+ " }",
+ "}");
+ JavaFileObject autoValueClass =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "",
+ "@AutoValue",
+ "abstract class Baz<T> implements Parent<Baz.Builder<T>> {",
+ " abstract T thing();",
+ " static <T> Builder<T> builder() {",
+ " return new AutoValue_Baz.Builder<>();",
+ " }",
+ "",
+ " @AutoValue.Builder",
+ " abstract static class Builder<T> implements Parent.Builder<T, Builder<T>, Baz<T>> {",
+ " }",
+ "}");
+ ContextChecker checker =
+ context -> {
+ assertThat(context.builder()).isPresent();
+ BuilderContext builderContext = context.builder().get();
+
+ assertThat(builderContext.builderType().getQualifiedName().toString())
+ .isEqualTo("foo.bar.Baz.Builder");
+
+ Set<ExecutableElement> builderMethods = builderContext.builderMethods();
+ assertThat(builderMethods).hasSize(1);
+ ExecutableElement builderMethod = Iterables.getOnlyElement(builderMethods);
+ assertThat(builderMethod.getSimpleName().toString()).isEqualTo("builder");
+
+ Set<ExecutableElement> toBuilderMethods = builderContext.toBuilderMethods();
+ assertThat(toBuilderMethods).hasSize(1);
+ ExecutableElement toBuilderMethod = Iterables.getOnlyElement(toBuilderMethods);
+ assertThat(toBuilderMethod.getSimpleName().toString()).isEqualTo("toBuilder");
+
+ Optional<ExecutableElement> buildMethod = builderContext.buildMethod();
+ assertThat(buildMethod).isPresent();
+ assertThat(buildMethod.get().getSimpleName().toString()).isEqualTo("build");
+ assertThat(buildMethod.get().getParameters()).isEmpty();
+ assertThat(buildMethod.get().getReturnType().toString()).isEqualTo("BuiltT");
+
+ ExecutableElement autoBuildMethod = builderContext.autoBuildMethod();
+ assertThat(autoBuildMethod).isEqualTo(buildMethod.get());
+
+ Map<String, Set<ExecutableElement>> setters = builderContext.setters();
+ assertThat(setters.keySet()).containsExactly("thing");
+ Set<ExecutableElement> thingSetters = setters.get("thing");
+ assertThat(thingSetters).hasSize(1);
+ ExecutableElement thingSetter = Iterables.getOnlyElement(thingSetters);
+ assertThat(thingSetter.getSimpleName().toString()).isEqualTo("setThing");
+ };
+ ContextCheckingExtension extension = new ContextCheckingExtension(checker);
+ Compilation compilation =
+ javac()
+ .withProcessors(new AutoValueProcessor(ImmutableList.of(extension)))
+ .compile(autoValueClass, parent);
+ assertThat(compilation).succeededWithoutWarnings();
+ }
+
+ @Test
public void oddBuilderContext() {
- JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
- "foo.bar.Baz",
- "package foo.bar;",
- "",
- "import com.google.auto.value.AutoValue;",
- "import com.google.common.collect.ImmutableList;",
- "",
- "@AutoValue",
- "abstract class Baz {",
- " abstract String string();",
- "",
- " @AutoValue.Builder",
- " abstract static class Builder {",
- " abstract Builder setString(String x);",
- " abstract Baz oddBuild();",
- " Baz build(int butNotReallyBecauseOfThisParameter) {",
- " return null;",
- " }",
- " }",
- "}");
+ JavaFileObject autoValueClass =
+ JavaFileObjects.forSourceLines(
+ "foo.bar.Baz",
+ "package foo.bar;",
+ "",
+ "import com.google.auto.value.AutoValue;",
+ "import com.google.common.collect.ImmutableList;",
+ "",
+ "@AutoValue",
+ "abstract class Baz {",
+ " abstract String string();",
+ "",
+ " @AutoValue.Builder",
+ " abstract static class Builder {",
+ " abstract Builder setString(String x);",
+ " abstract Baz oddBuild();",
+ " Baz build(int butNotReallyBecauseOfThisParameter) {",
+ " return null;",
+ " }",
+ " }",
+ "}");
ContextChecker checker =
context -> {
assertThat(context.builder()).isPresent();
@@ -1126,25 +1207,26 @@
// https://github.com/google/auto/issues/809
@Test
public void propertyErrorShouldNotCrash() {
- JavaFileObject autoValueClass = JavaFileObjects.forSourceLines(
- "test.Test",
- "package test;",
- "import com.google.auto.value.AutoValue;",
- "import java.util.List;",
- "",
- "@AutoValue",
- "public abstract class Test {",
- " abstract Integer property();",
- " abstract List<String> listProperty();",
- "",
- " @AutoValue.Builder",
- " public interface Builder {",
- " Builder property(Integer property);",
- " Builder listProperty(List<String> listProperty);",
- " Builder listProperty(Integer listPropertyValues);",
- " Test build();",
- " }",
- "}");
+ JavaFileObject autoValueClass =
+ JavaFileObjects.forSourceLines(
+ "test.Test",
+ "package test;",
+ "import com.google.auto.value.AutoValue;",
+ "import java.util.List;",
+ "",
+ "@AutoValue",
+ "public abstract class Test {",
+ " abstract Integer property();",
+ " abstract List<String> listProperty();",
+ "",
+ " @AutoValue.Builder",
+ " public interface Builder {",
+ " Builder property(Integer property);",
+ " Builder listProperty(List<String> listProperty);",
+ " Builder listProperty(Integer listPropertyValues);",
+ " Test build();",
+ " }",
+ "}");
// We don't actually expect the extension to be invoked. Previously it was, and that led to a
// NullPointerException when calling .setters() in the checker.
ContextChecker checker =
diff --git a/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java b/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java
index f3d3d61..18cca5e 100644
--- a/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/GeneratedDoesNotExistTest.java
@@ -48,6 +48,8 @@
*/
@RunWith(Parameterized.class)
public class GeneratedDoesNotExistTest {
+ private static final ImmutableList<String> STANDARD_OPTIONS =
+ ImmutableList.of("-A" + Nullables.NULLABLE_OPTION + "=");
@Parameters(name = "{0}")
public static Collection<Object[]> data() {
@@ -57,12 +59,16 @@
// TODO(b/72513371): use --release 8 once compile-testing supports that
params.add(
new Object[] {
- ImmutableList.of(), "javax.annotation.processing.Generated",
+ STANDARD_OPTIONS, "javax.annotation.processing.Generated",
});
}
params.add(
new Object[] {
- ImmutableList.of("-source", "8", "-target", "8"), "javax.annotation.Generated",
+ ImmutableList.<String>builder()
+ .addAll(STANDARD_OPTIONS)
+ .add("-source", "8", "-target", "8")
+ .build(),
+ "javax.annotation.Generated",
});
return params.build();
}
@@ -223,9 +229,9 @@
Processor noGeneratedProcessor = partialProxy(Processor.class, handler);
Compilation compilation =
javac()
- .withOptions(javacOptions)
- .withProcessors(noGeneratedProcessor)
- .compile(javaFileObject);
+ .withOptions(javacOptions)
+ .withProcessors(noGeneratedProcessor)
+ .compile(javaFileObject);
assertThat(compilation).succeededWithoutWarnings();
assertThat(compilation)
.generatedSourceFile("foo.bar.AutoValue_Baz")
diff --git a/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java b/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java
index 27cb093..472f62d 100644
--- a/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/IncrementalExtensionTest.java
@@ -22,6 +22,7 @@
import com.google.auto.value.extension.AutoValueExtension.IncrementalExtensionType;
import com.google.auto.value.extension.memoized.processor.MemoizeExtension;
import com.google.auto.value.extension.serializable.processor.SerializableAutoValueExtension;
+import com.google.auto.value.extension.toprettystring.processor.ToPrettyStringExtension;
import com.google.common.collect.ImmutableList;
import javax.annotation.processing.ProcessingEnvironment;
import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType;
@@ -46,7 +47,10 @@
// different <?>.
assertThat(builtInExtensions)
.comparingElementsUsing(transforming(e -> (Object) e.getClass(), "is class"))
- .containsExactly(MemoizeExtension.class, SerializableAutoValueExtension.class);
+ .containsExactly(
+ MemoizeExtension.class,
+ SerializableAutoValueExtension.class,
+ ToPrettyStringExtension.class);
AutoValueProcessor processor = new AutoValueProcessor(builtInExtensions);
assertThat(processor.getSupportedOptions())
@@ -58,10 +62,12 @@
AutoValueExtension nonIsolatingExtension = new NonIsolatingExtension();
assertThat(nonIsolatingExtension.incrementalType((ProcessingEnvironment) null))
.isEqualTo(IncrementalExtensionType.UNKNOWN);
- ImmutableList<AutoValueExtension> extensions = ImmutableList.<AutoValueExtension>builder()
- .addAll(AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
- .add(nonIsolatingExtension)
- .build();
+ ImmutableList<AutoValueExtension> extensions =
+ ImmutableList.<AutoValueExtension>builder()
+ .addAll(
+ AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
+ .add(nonIsolatingExtension)
+ .build();
AutoValueProcessor processor = new AutoValueProcessor(extensions);
assertThat(processor.getSupportedOptions())
@@ -73,10 +79,12 @@
AutoValueExtension isolatingExtension = new IsolatingExtension();
assertThat(isolatingExtension.incrementalType((ProcessingEnvironment) null))
.isEqualTo(IncrementalExtensionType.ISOLATING);
- ImmutableList<AutoValueExtension> extensions = ImmutableList.<AutoValueExtension>builder()
- .addAll(AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
- .add(isolatingExtension)
- .build();
+ ImmutableList<AutoValueExtension> extensions =
+ ImmutableList.<AutoValueExtension>builder()
+ .addAll(
+ AutoValueProcessor.extensionsFromLoader(AutoValueProcessor.class.getClassLoader()))
+ .add(isolatingExtension)
+ .build();
AutoValueProcessor processor = new AutoValueProcessor(extensions);
assertThat(processor.getSupportedOptions())
diff --git a/value/src/test/java/com/google/auto/value/processor/NullablesTest.java b/value/src/test/java/com/google/auto/value/processor/NullablesTest.java
new file mode 100644
index 0000000..9e345f5
--- /dev/null
+++ b/value/src/test/java/com/google/auto/value/processor/NullablesTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * 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.processor;
+
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.OptionalSubject.optionals;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static java.util.stream.Collectors.partitioningBy;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.google.common.truth.Expect;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.Compiler;
+import com.google.testing.compile.JavaFileObjects;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.util.ElementFilter;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class NullablesTest {
+ @Rule public Expect expect = Expect.create();
+
+ @Target(ElementType.TYPE_USE)
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface Nullable {}
+
+ @Target(ElementType.TYPE_USE)
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface Irrelevant {}
+
+ // The class here has various methods that we will examine with
+ // Nullables.nullableMentionedInMethods to ensure that we do indeed detect @Nullable annotations
+ // in various contexts.
+ // This test is a lot more complicated than it should be. Ideally we would just have this Methods
+ // class be an actual class nested inside this test, and we would use CompilationRule to get
+ // the corresponding TypeElement so we could check the various methods. Unfortunately, if we
+ // do that then we get a TypeElement where all type annotations have disappeared because of
+ // https://bugs.openjdk.java.net/browse/JDK-8225377. So instead we have to use Compiler to compile
+ // the code here with a special annotation processor that will check the annotations of the
+ // just-compiled class. Since the processor is running as part of the same compilation, we don't
+ // lose the type annotations.
+
+ private static final ImmutableList<String> METHOD_LINES =
+ ImmutableList.of(
+ // Methods in this class whose names begin with "no" do not mention @Nullable anywhere.",
+ // All other methods do.",
+ "package foo.bar;",
+ "",
+ "import " + Irrelevant.class.getCanonicalName() + ";",
+ "import " + Nullable.class.getCanonicalName() + ";",
+ "import java.util.List;",
+ "",
+ "abstract class Methods {",
+ " void noAnnotations() {}",
+ " abstract int noAnnotationsEither(int x);",
+ " abstract @Irrelevant String noRelevantAnnotations(@Irrelevant int x);",
+ " abstract @Nullable String nullableString();",
+ " abstract String @Nullable [] nullableArrayOfString();",
+ " abstract @Nullable String[] arrayOfNullableString();",
+ " abstract @Nullable String @Nullable [] nullableArrayOfNullableString();",
+ " abstract List<@Nullable String> listOfNullableString();",
+ " abstract List<? extends @Nullable Object> listOfExtendsNullable();",
+ " abstract List<? super @Nullable Number> listOfSuperNullable();",
+ " abstract <T extends @Nullable Object> T nullableTypeParamBound();",
+ " abstract <T> @Nullable T nullableTypeParamRef();",
+ " void nullableParam(@Nullable String x) {}",
+ " void nullableParamBound(List<? extends @Nullable String> x) {}",
+ "}");
+
+ @Test
+ public void nullableMentionedInMethods() {
+ // Sadly we can't rely on JDK 8 to handle type annotations correctly.
+ // Some versions do, some don't. So skip the test unless we are on at least JDK 9.
+ double javaVersion = Double.parseDouble(JAVA_SPECIFICATION_VERSION.value());
+ assume().that(javaVersion).isAtLeast(9.0);
+ NullableProcessor processor = new NullableProcessor(expect);
+ Compilation compilation =
+ Compiler.javac()
+ .withProcessors(processor)
+ .compile(JavaFileObjects.forSourceLines("foo.bar.Methods", METHOD_LINES));
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(processor.ran).isTrue();
+ // If any `expect` calls failed then the test will fail now because of the Expect rule.
+ }
+
+ @SupportedAnnotationTypes("*")
+ private static class NullableProcessor extends AbstractProcessor {
+
+ private final Expect expect;
+ boolean ran;
+
+ NullableProcessor(Expect expect) {
+ this.expect = expect;
+ }
+
+ @Override
+ public SourceVersion getSupportedSourceVersion() {
+ return SourceVersion.latestSupported();
+ }
+
+ @Override
+ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+ if (roundEnv.processingOver()) {
+ TypeElement methodsElement =
+ processingEnv.getElementUtils().getTypeElement("foo.bar.Methods");
+ expect.that(methodsElement).isNotNull();
+
+ List<ExecutableElement> methods =
+ ElementFilter.methodsIn(methodsElement.getEnclosedElements());
+ Map<Boolean, List<ExecutableElement>> partitionedMethods =
+ methods.stream()
+ .collect(partitioningBy(p -> !p.getSimpleName().toString().startsWith("no")));
+ List<ExecutableElement> nullableMethods = partitionedMethods.get(true);
+ List<ExecutableElement> notNullableMethods = partitionedMethods.get(false);
+
+ expect
+ .about(optionals())
+ .that(Nullables.nullableMentionedInMethods(notNullableMethods))
+ .isEmpty();
+
+ TypeElement nullableElement =
+ processingEnv.getElementUtils().getTypeElement(Nullable.class.getCanonicalName());
+ expect.that(nullableElement).isNotNull();
+ DeclaredType nullableType = MoreTypes.asDeclared(nullableElement.asType());
+
+ for (ExecutableElement nullableMethod : nullableMethods) {
+ // Make a list with all the methods that don't have @Nullable plus one method that does.
+ ImmutableList<ExecutableElement> notNullablePlusNullable =
+ ImmutableList.<ExecutableElement>builder()
+ .addAll(notNullableMethods)
+ .add(nullableMethod)
+ .build();
+ expect
+ .withMessage("method %s should have @Nullable", nullableMethod)
+ .about(optionals())
+ .that(
+ Nullables.nullableMentionedInMethods(notNullablePlusNullable)
+ .map(AnnotationMirror::getAnnotationType))
+ .hasValue(nullableType);
+ }
+ ran = true;
+ }
+ return false;
+ }
+ }
+}
diff --git a/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java b/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java
index 2c3bea0..48d8cd6 100644
--- a/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/PropertyAnnotationsTest.java
@@ -15,12 +15,13 @@
*/
package com.google.auto.value.processor;
-import static com.google.common.truth.Truth.assertAbout;
-import static com.google.testing.compile.JavaSourceSubjectFactory.javaSource;
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSet;
+import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
@@ -40,8 +41,7 @@
*/
@RunWith(JUnit4.class)
public class PropertyAnnotationsTest {
- private static final String TEST_ANNOTATION =
- "@PropertyAnnotationsTest.TestAnnotation";
+ private static final String TEST_ANNOTATION = "@PropertyAnnotationsTest.TestAnnotation";
private static final String TEST_ARRAY_ANNOTATION =
"@PropertyAnnotationsTest.TestArrayAnnotation";
@@ -272,12 +272,15 @@
.addMethodAnnotations(expectedMethodAnnotations)
.build();
- assertAbout(javaSource())
- .that(javaFileObject)
- .processedWith(new AutoValueProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(expectedOutput);
+ Compilation compilation =
+ javac()
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
+ .withProcessors(new AutoValueProcessor())
+ .compile(javaFileObject);
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .generatedSourceFile("foo.bar.AutoValue_Baz")
+ .hasSourceEquivalentTo(expectedOutput);
}
@Test
@@ -445,10 +448,12 @@
assertGeneratedMatches(
getImports(PropertyAnnotationsTest.class),
ImmutableList.of(
- TEST_ARRAY_ANNOTATION + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
+ TEST_ARRAY_ANNOTATION
+ + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
+ " PropertyAnnotationsTest.TestEnum.B})"),
ImmutableList.of(
- TEST_ARRAY_ANNOTATION + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
+ TEST_ARRAY_ANNOTATION
+ + "(testEnums = {PropertyAnnotationsTest.TestEnum.A,"
+ " PropertyAnnotationsTest.TestEnum.B})"));
}
@@ -512,12 +517,15 @@
.addFieldAnnotations("@Deprecated", "@PropertyAnnotationsTest.InheritedAnnotation")
.build();
- assertAbout(javaSource())
- .that(inputFile)
- .processedWith(new AutoValueProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(outputFile);
+ Compilation compilation =
+ javac()
+ .withOptions("-A" + Nullables.NULLABLE_OPTION)
+ .withProcessors(new AutoValueProcessor())
+ .compile(inputFile);
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .generatedSourceFile("foo.bar.AutoValue_Baz")
+ .hasSourceEquivalentTo(outputFile);
}
/**
@@ -545,16 +553,17 @@
.setImports(getImports(PropertyAnnotationsTest.class))
.addFieldAnnotations("@Deprecated", "@PropertyAnnotationsTest.InheritedAnnotation")
.addMethodAnnotations(
- "@Deprecated",
- "@PropertyAnnotationsTest.InheritedAnnotation",
- "@Baz.MethodsOnly")
+ "@Deprecated", "@PropertyAnnotationsTest.InheritedAnnotation", "@Baz.MethodsOnly")
.build();
- assertAbout(javaSource())
- .that(inputFile)
- .processedWith(new AutoValueProcessor())
- .compilesWithoutError()
- .and()
- .generatesSources(outputFile);
+ Compilation compilation =
+ javac()
+ .withOptions("-A" + Nullables.NULLABLE_OPTION + "=")
+ .withProcessors(new AutoValueProcessor())
+ .compile(inputFile);
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .generatedSourceFile("foo.bar.AutoValue_Baz")
+ .hasSourceEquivalentTo(outputFile);
}
}
diff --git a/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java b/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java
index 7af240c..d488e59 100644
--- a/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/PropertyNamesTest.java
@@ -34,14 +34,12 @@
.put("x", "x")
.put("", "")
.build();
-
+
@Test
public void decapitalizeLikeJavaBeans() {
- NORMAL_CASES
- .forEach(
- (input, output) -> {
- expect.that(PropertyNames.decapitalizeLikeJavaBeans(input)).isEqualTo(output);
- });
+ NORMAL_CASES.forEach(
+ (input, output) ->
+ expect.that(PropertyNames.decapitalizeLikeJavaBeans(input)).isEqualTo(output));
expect.that(PropertyNames.decapitalizeLikeJavaBeans(null)).isNull();
expect.that(PropertyNames.decapitalizeLikeJavaBeans("HTMLPage")).isEqualTo("HTMLPage");
expect.that(PropertyNames.decapitalizeLikeJavaBeans("OAuth")).isEqualTo("OAuth");
@@ -49,11 +47,9 @@
@Test
public void decapitalizeNormally() {
- NORMAL_CASES
- .forEach(
- (input, output) -> {
- expect.that(PropertyNames.decapitalizeNormally(input)).isEqualTo(output);
- });
+ NORMAL_CASES.forEach(
+ (input, output) ->
+ expect.that(PropertyNames.decapitalizeNormally(input)).isEqualTo(output));
expect.that(PropertyNames.decapitalizeNormally(null)).isNull();
expect.that(PropertyNames.decapitalizeNormally("HTMLPage")).isEqualTo("hTMLPage");
expect.that(PropertyNames.decapitalizeNormally("OAuth")).isEqualTo("oAuth");
diff --git a/value/src/test/java/com/google/auto/value/processor/ReformatterTest.java b/value/src/test/java/com/google/auto/value/processor/ReformatterTest.java
index 98d31b4..48ecf5b 100644
--- a/value/src/test/java/com/google/auto/value/processor/ReformatterTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/ReformatterTest.java
@@ -15,7 +15,7 @@
*/
package com.google.auto.value.processor;
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -29,7 +29,7 @@
@RunWith(JUnit4.class)
public class ReformatterTest {
@Test
- public void testSimple() {
+ public void simple() {
String input =
"\n"
+ "package com.latin.declension; \n"
@@ -50,7 +50,7 @@
+ "\n"
+ " Eodem ( Eadem eodem ) { }\n";
String output =
- "package com.latin.declension;\n"
+ "package com.latin.declension;\n"
+ "\n"
+ "public class Idem {\n"
+ "\n"
@@ -62,11 +62,11 @@
+ " }\n"
+ "\n"
+ " Eodem (Eadem eodem) { }\n";
- assertEquals(output, Reformatter.fixup(input));
+ assertThat(Reformatter.fixup(input)).isEqualTo(output);
}
@Test
- public void testSpecialSpaces() {
+ public void specialSpaces() {
String input =
"\n"
+ "package com.example.whatever;\n"
@@ -79,7 +79,7 @@
+ " static final char QUOTE2 = '\\\"' ;\n"
+ "}\n";
String output =
- "package com.example.whatever;\n"
+ "package com.example.whatever;\n"
+ "\n"
+ "public class SomeClass {\n"
+ " static final String STRING = \" hello world \\n\";\n"
@@ -88,13 +88,66 @@
+ " static final char QUOTE = '\"';\n"
+ " static final char QUOTE2 = '\\\"';\n"
+ "}\n";
- assertEquals(output, Reformatter.fixup(input));
+ assertThat(Reformatter.fixup(input)).isEqualTo(output);
}
@Test
public void noTrailingNewline() {
String input = "package com.example.whatever;\n\npublic class SomeClass {}";
String output = input + "\n";
- assertEquals(output, Reformatter.fixup(input));
+ assertThat(Reformatter.fixup(input)).isEqualTo(output);
+ }
+
+ @Test
+ public void indent() {
+ String input =
+ " class Test {\n"
+ + "private final int field;\n"
+ + "\n"
+ + "Test(\n"
+ + "@Interesting Integer field,\n"
+ + "boolean ignored) {\n"
+ + "this.field = field;\n"
+ + "}\n"
+ + "\n"
+ + "@Override\n"
+ + "public boolean equals(Object x) {\n"
+ + "return x instanceof Test\n"
+ + "&& ((Test) x).field == field;\n"
+ + "// interesting\n"
+ + "}\n"
+ + "\n"
+ + "@Override\n"
+ + "public String toString() {\n"
+ + "return \"Test{\"\n"
+ + "+ \"field=\" + field\n"
+ + "+ \"}\";\n"
+ + "}\n"
+ + "}\n";
+ String output =
+ "class Test {\n"
+ + " private final int field;\n"
+ + "\n"
+ + " Test(\n"
+ + " @Interesting Integer field,\n"
+ + " boolean ignored) {\n"
+ + " this.field = field;\n"
+ + " }\n"
+ + "\n"
+ + " @Override\n"
+ + " public boolean equals(Object x) {\n"
+ + " return x instanceof Test\n"
+ + " && ((Test) x).field == field;\n"
+ + " // interesting\n"
+ + " }\n"
+ + "\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return \"Test{\"\n"
+ + " + \"field=\" + field\n"
+ + " + \"}\";\n"
+ + " }\n"
+ + "}\n";
+ assertThat(Reformatter.fixup(input)).isEqualTo(output);
}
}
diff --git a/value/src/test/java/com/google/auto/value/processor/SimpleServiceLoaderTest.java b/value/src/test/java/com/google/auto/value/processor/SimpleServiceLoaderTest.java
index fab1805..5e2d230 100644
--- a/value/src/test/java/com/google/auto/value/processor/SimpleServiceLoaderTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/SimpleServiceLoaderTest.java
@@ -28,6 +28,8 @@
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.ServiceConfigurationError;
@@ -54,6 +56,35 @@
assertThat(classes).containsExactly(String.class, StringBuilder.class).inOrder();
}
+ // Sometimes you can have the same jar appear more than once in the classpath, perhaps in
+ // different versions. In that case we don't want to instantiate the same class more than once.
+ // This test checks that we don't.
+ @Test
+ public void loadWithDuplicates() throws Exception {
+ ClassLoader loader1 =
+ loaderForJarWithEntries(
+ CharSequence.class.getName(), String.class.getName(), StringBuilder.class.getName());
+ ClassLoader loader2 =
+ loaderForJarWithEntries(
+ CharSequence.class.getName(), String.class.getName(), StringBuilder.class.getName());
+ ClassLoader combinedLoader =
+ new ClassLoader() {
+ @Override
+ public Enumeration<URL> getResources(String name) throws IOException {
+ List<URL> urls = new ArrayList<>(Collections.list(loader1.getResources(name)));
+ urls.addAll(Collections.list(loader2.getResources(name)));
+ return Collections.enumeration(urls);
+ }
+ };
+
+ ImmutableList<CharSequence> providers =
+ SimpleServiceLoader.load(CharSequence.class, combinedLoader);
+
+ assertThat(providers).contains("");
+ List<Class<?>> classes = providers.stream().map(Object::getClass).collect(toList());
+ assertThat(classes).containsExactly(String.class, StringBuilder.class).inOrder();
+ }
+
@Test
public void blankLinesAndComments() throws Exception {
ClassLoader loader =
diff --git a/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java b/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java
index 39e2dc0..7bc6779 100644
--- a/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/SimplifyWithAnnotationsTest.java
@@ -157,8 +157,7 @@
void testTypeSpellings(TypeElement testClass) {
ExecutableElement witness =
- ElementFilter.methodsIn(testClass.getEnclosedElements())
- .stream()
+ ElementFilter.methodsIn(testClass.getEnclosedElements()).stream()
.filter(m -> m.getSimpleName().contentEquals("witness"))
.collect(onlyElement());
if (witness.getReturnType().getAnnotationMirrors().isEmpty()) {
diff --git a/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java b/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java
index c31f711..83951e0 100644
--- a/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/TypeEncoderTest.java
@@ -292,7 +292,7 @@
TypeMirror multipleBoundsMirror = multipleBoundsElement.asType();
String text = "`import`\n";
text += "{" + TypeEncoder.encode(multipleBoundsMirror) + "}";
- text += "{" + TypeEncoder.formalTypeParametersString(multipleBoundsElement) + "}";
+ text += "{" + TypeEncoder.typeParametersString(multipleBoundsElement.getTypeParameters()) + "}";
String myPackage = getClass().getPackage().getName();
String decoded =
TypeEncoder.decode(text, elementUtils, typeUtils, myPackage, baseWithoutContainedTypes());
@@ -306,6 +306,7 @@
@SuppressWarnings("ClassCanBeStatic")
static class Outer<T extends Number> {
class InnerWithoutTypeParam {}
+
class Middle<U> {
class InnerWithTypeParam<V> {}
}
diff --git a/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java b/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java
index 078ef51..895bed2 100644
--- a/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java
+++ b/value/src/test/java/com/google/auto/value/processor/TypeVariablesTest.java
@@ -115,10 +115,12 @@
abstract static class Outer<T, U extends T> {
abstract Map<T, U> getFoo();
+
abstract List<? extends T> getBar();
abstract static class Inner<T, U extends T> {
abstract void setFoo(Map<T, U> foo);
+
abstract void setBar(List<? extends T> bar);
}
}
@@ -165,13 +167,15 @@
List<ExecutableElement> immutableMapMethods =
ElementFilter.methodsIn(immutableMap.getEnclosedElements());
ExecutableElement copyOf = methodNamed(immutableMapMethods, "copyOf", erasedMap);
- expect.that(
- TypeVariables.canAssignStaticMethodResult(
- copyOf, immutableMapStringInteger, immutableMapStringNumber, typeUtils))
+ expect
+ .that(
+ TypeVariables.canAssignStaticMethodResult(
+ copyOf, immutableMapStringInteger, immutableMapStringNumber, typeUtils))
.isTrue();
- expect.that(
- TypeVariables.canAssignStaticMethodResult(
- copyOf, immutableMapStringNumber, immutableMapStringInteger, typeUtils))
+ expect
+ .that(
+ TypeVariables.canAssignStaticMethodResult(
+ copyOf, immutableMapStringNumber, immutableMapStringInteger, typeUtils))
.isFalse();
}
@@ -184,7 +188,9 @@
return methods.stream()
.filter(m -> m.getSimpleName().contentEquals(name))
.filter(m -> m.getParameters().size() == 1)
- .filter(m -> typeUtils.isSameType(
+ .filter(
+ m ->
+ typeUtils.isSameType(
erasedParameterType, typeUtils.erasure(m.getParameters().get(0).asType())))
.findFirst()
.get();
diff --git a/value/userguide/autobuilder.md b/value/userguide/autobuilder.md
new file mode 100644
index 0000000..ccd191c
--- /dev/null
+++ b/value/userguide/autobuilder.md
@@ -0,0 +1,491 @@
+# AutoBuilder
+
+
+AutoBuilder makes it easy to create a generalized builder, with setter methods
+that accumulate values, and a build method that calls a constructor or static
+method with those values as parameters. Callers don't need to know the order of
+those parameters. Parameters can also have default values. There can be
+validation before the constructor or method call.
+
+If you are familiar with [AutoValue builders](builders.md) then AutoBuilder
+should also be familiar. Where an `@AutoValue.Builder` has setter methods
+corresponding to the getter methods in the `@AutoValue` class, an `@AutoBuilder`
+has setter methods corresponding to the parameters of a constructor or static
+method. Apart from that, the two are very similar.
+
+AutoBuilder is **unstable** and it is possible that its API
+may change. We do not recommend depending on it for production code yet.
+
+## Example: calling a constructor
+
+Here is a simple example:
+
+```
+@AutoBuilder(ofClass = Person.class)
+abstract class PersonBuilder {
+ static PersonBuilder personBuilder() {
+ return new AutoBuilder_PersonBuilder();
+ }
+
+ abstract PersonBuilder setName(String name);
+ abstract PersonBuilder setId(int id);
+ abstract Person build();
+}
+```
+
+It might be used like this:
+
+```
+Person p = PersonBuilder.personBuilder().setName("Priz").setId(6).build();
+```
+
+That would have the same effect as this:
+
+```
+Person p = new Person("Priz", 6);
+```
+
+But it doesn't require you to know what order the constructor parameters are in.
+
+Here, `setName` and `setId` are _setter methods_. Calling
+`builder.setName("Priz")` records the value `"Priz"` for the parameter `name`,
+and likewise with `setId`.
+
+There is also a `build()` method. Calling that method invokes the `Person`
+constructor with the parameters that were previously set.
+
+## Example: calling a Kotlin constructor
+
+Kotlin has named arguments and default arguments for constructors and functions,
+which means there is not much need for anything like AutoBuilder there. But if
+you are constructing an instance of a Kotlin data class from Java code,
+AutoBuilder can help.
+
+Given this trivial Kotlin data class:
+
+```
+class KotlinData(val int: Int, val string: String?)
+```
+
+You might make a builder for it like this:
+
+```
+@AutoBuilder(ofClass = KotlinData.class)
+public abstract class KotlinDataBuilder {
+ public static KotlinDataBuilder kotlinDataBuilder() {
+ return new AutoBuilder_KotlinDataBuilder();
+ }
+
+ public abstract setInt(int x);
+ public abstract setString(@Nullable String x);
+ public abstract KotlinData build();
+}
+```
+
+The Kotlin type `String?` corresponds to `@Nullable String` in the AutoBuilder
+class, where `@Nullable` is any annotation with that name, such as
+`org.jetbrains.annotations.Nullable`.
+
+## The generated subclass
+
+Like `@AutoValue.Builder`, compiling an `@AutoBuilder` class will generate a
+concrete subclass. In the example above, this will be `class
+AutoBuilder_PersonBuilder extends PersonBuilder`. It is common to have a static
+`builder()` method, as in the example, which calls `new AutoBuilder_...()`. That
+will typically be the only reference to the generated class.
+
+If the `@AutoBuilder` type is nested then the name of the generated class
+reflects that nesting. For example:
+
+```
+class Outer {
+ static class Inner {
+ @AutoBuilder
+ abstract static class Builder {...}
+ }
+ static Inner.Builder builder() {
+ return new AutoBuilder_Outer_Inner_Builder();
+ }
+}
+```
+
+## `@AutoBuilder` annotation parameters
+
+`@AutoBuilder` has two annotation parameters, `ofClass` and `callMethod`.
+
+If `ofClass` is specified, then `build()` will call a constructor or static
+method of that class. Otherwise it will call a constructor or static method of
+the class _containing_ the `@AutoBuilder` class.
+
+If `callMethod` is specified, then `build()` will call a static method with that
+name. Otherwise `build()` will call a constructor.
+
+The following examples illustrate the various possibilities. These examples use
+an interface for the `@AutoBuilder` type. You can also use an abstract class; if
+it is nested then it must be static.
+
+### Both `callMethod` and `ofClass`
+
+```
+@AutoBuilder(callMethod = "of", ofClass = LocalTime.class)
+interface LocalTimeBuilder {
+ ...
+ LocalTime build(); // calls: LocalTime.of(...)
+}
+```
+
+### Only `ofClass`
+
+```
+@AutoBuilder(ofClass = Thread.class)
+interface ThreadBuilder {
+ ...
+ Thread build(); // calls: new Thread(...)
+}
+```
+
+### Only `callMethod`
+
+```
+class Foo {
+ static String concat(String first, String middle, String last) {...}
+
+ @AutoBuilder(callMethod = "concat")
+ interface ConcatBuilder {
+ ...
+ String build(); // calls: Foo.concat(first, middle, last)
+ }
+}
+```
+
+Notice in this example that the static method returns `String`. The implicit
+`ofClass` is `Foo`, but the static method can return any type.
+
+### Neither `callMethod` nor `ofClass`
+
+```
+class Person {
+ Person(String name, int id) {...}
+
+ @AutoBuilder
+ interface Builder {
+ ...
+ Person build(); // calls: new Person(name, id)
+ }
+}
+```
+
+## The build method
+
+The build method must have a certain return type. If it calls a constructor then
+its return type must be the type of the constructed class. If it calls a static
+method then its return type must be the return type of the static method.
+
+The build method is often called `build()` but it does not have to be. The only
+requirement is that there must be exactly one no-arg abstract method that has
+the return type just described and that does not correspond to a parameter name.
+
+The following example uses the name `call()` since that more accurately reflects
+what it does:
+
+```
+public class LogUtil {
+ public static void log(Level severity, String message, Object... params) {...}
+
+ @AutoBuilder(callMethod = "log")
+ public interface Caller {
+ Caller setSeverity(Level level);
+ Caller setMessage(String message);
+ Caller setParams(Object... params);
+ void call(); // calls: LogUtil.log(severity, message, params)
+ }
+```
+
+## Overloaded constructors or methods
+
+There might be more than one constructor or static method that matches the
+`callMethod` and `ofClass`. AutoBuilder will ignore any that are not visible to
+the generated class, meaning private, or package-private and in a different
+package. Of the others, it will pick the one whose parameter names match the
+`@AutoBuilder` setter methods. It is a compilation error if there is not exactly
+one such method or constructor.
+
+## Generics
+
+If the builder calls the constructor of a generic type, then it must have the
+same type parameters as that type, as in this example:
+
+```
+class NumberPair<T extends Number> {
+ NumberPair(T first, T second) {...}
+
+ @AutoBuilder
+ interface Builder<T extends Number> {
+ Builder<T> setFirst(T x);
+ Builder<T> setSecond(T x);
+ NumberPair<T> build();
+ }
+}
+```
+
+If the builder calls a static method with type parameters, then it must have the
+same type parameters, as in this example:
+
+```
+class Utils {
+ static <K extends Number, V> Map<K, V> singletonNumberMap(K key, V value) {...}
+
+ @AutoBuilder(callMethod = "singletonNumberMap")
+ interface Builder<K extends Number, V> {
+ Builder<K, V> setKey(K x);
+ Builder<K, V> setValue(V x);
+ Map<K, V> build();
+ }
+}
+```
+
+Although it's unusual, a Java constructor can have its own type parameters,
+separately from any that its containing class might have. A builder that calls a
+constructor like that must have the type parameters of the class followed by the
+type parameters of the constructor:
+
+```
+class CheckedSet<E> implements Set<E> {
+ <T extends E> CheckedSet(Class<T> type) {...}
+
+ @AutoBuilder
+ interface Builder<E, T extends E> {
+ Builder<E, T> setType(Class<T> type);
+ CheckedSet<E> build();
+ }
+}
+```
+
+## Required, optional, and nullable parameters
+
+Parameters that are annotated `@Nullable` are null by default. Parameters of
+type `Optional`, `OptionalInt`, `OptionalLong`, and `OptionalDouble` are empty
+by default. Every other parameter is _required_, meaning that the build method
+will throw `IllegalStateException` if any are omitted.
+
+To establish default values for parameters, set them in the `builder()` method
+before returning the builder.
+
+```
+class Foo {
+ Foo(String bar, @Nullable String baz, String buh) {...}
+
+ static Builder builder() {
+ return new AutoBuilder_Foo_Builder()
+ .setBar(DEFAULT_BAR);
+ }
+
+ @AutoBuilder
+ interface Builder {
+ Builder setBar(String x);
+ Builder setBaz(String x);
+ Builder setBuh(String x);
+ Foo build();
+ }
+
+ {
+ builder().build(); // IllegalStateException, buh is not set
+ builder().setBuh("buh").build(); // OK, bar=DEFAULT_BAR and baz=null
+ builder().setBaz(null).setBuh("buh").build(); // OK
+ builder().setBar(null); // NullPointerException, bar is not @Nullable
+ }
+}
+```
+
+Trying to set a parameter that is _not_ annotated `@Nullable` to `null` will
+produce a `NullPointerException`.
+
+`@Nullable` here is any annotation with that name, such as
+`javax.annotation.Nullable` or
+`org.checkerframework.checker.nullness.qual.Nullable`.
+
+## Getters
+
+The `@AutoBuilder` class or interface can also have _getter_ methods. A getter
+method returns the value that has been set for a certain parameter. Its return
+type can be either the same as the parameter type, or an `Optional` wrapping
+that type. Calling the getter before any value has been set will throw an
+exception in the first case or return an empty `Optional` in the second.
+
+In this example, the `nickname` parameter defaults to the same value as the
+`name` parameter but can also be set to a different value:
+
+```
+public class Named {
+ Named(String name, String nickname) {...}
+
+ @AutoBuilder
+ public abstract static class Builder {
+ public abstract Builder setName(String x);
+ public abstract Builder setNickname(String x);
+ abstract String getName();
+ abstract Optional<String> getNickname();
+ abstract Named autoBuild();
+
+ public Named build() {
+ if (!getNickname().isPresent()) {
+ setNickname(getName());
+ }
+ return autoBuild();
+ }
+ }
+}
+```
+
+The example illustrates having a package-private `autoBuild()` method that
+AutoBuilder implements. The public `build()` method calls it after adjusting the
+nickname if necessary.
+
+The builder in the example is an abstract class rather than an interface. An
+abstract class allows us to distinguish between public methods for users of the
+builder to call, and package-private methods that the builder's own logic uses.
+
+## Naming conventions
+
+A setter method for the parameter `foo` can be called either `setFoo` or `foo`.
+A getter method can be called either `getFoo` or `foo`, and for a `boolean`
+parameter it can also be called `isFoo`. The choice for getters and setters is
+independent. For example your getter might be `foo()` while your setter is
+`setFoo(T)`.
+
+By convention, the parameter name of a setter method either echoes the parameter
+being set:<br>
+`Builder setName(String name);`<br>
+or it is just `x`:<br>
+`Builder setName(String x);`<br>
+
+If class `Foo` has a nested `@AutoBuilder` that builds instances of `Foo`, then
+conventionally that type is called `Builder`, and instances of it are obtained
+by calling a static `Foo.builder()` method:
+
+```
+Foo foo1 = Foo.builder().setBar(bar).setBaz(baz).build();
+Foo.Builder fooBuilder = Foo.builder();
+```
+
+If an `@AutoBuilder` for `Foo` is its own top-level class then that class will
+typically be called `FooBuilder` and it will have a static `fooBuilder()` method
+that returns an instance of `FooBuilder`. That way callers can statically import
+`FooBuilder.fooBuilder` and just write `fooBuilder()` in their code.
+
+```
+@AutoBuilder(ofClass = Foo.class)
+public abstract class FooBuilder {
+ public static FooBuilder fooBuilder() {
+ return new AutoBuilder_FooBuilder();
+ }
+ ...
+ public abstract Foo build();
+}
+```
+
+If an `@AutoBuilder` is designed to call a static method that is not a factory
+method, the word "call" is better than "build" in the name of the type
+(`FooCaller`), the static method (`fooCaller()`), and the "build" method (`call()`).
+
+```
+@AutoBuilder(callMethod = "log", ofClass = MyLogger.class)
+public abstract class LogCaller {
+ public static LogCaller logCaller() {
+ return new AutoBuilder_LogCaller();
+ }
+ ...
+ public abstract void call();
+}
+
+// used as:
+logCaller().setLevel(Level.INFO).setMessage("oops").call();
+```
+
+## Other builder features
+
+There are a number of other builder features that have not been detailed here
+because they are the same as for `@AutoValue.Builder`. They include:
+
+* [Special treatment of collections](builders-howto.md#collection)
+* [Handling of nested builders](builders-howto.md#nested_builders)
+
+There is currently no equivalent of AutoValue's
+[`toBuilder()`](builders-howto.md#to_builder). Unlike AutoValue, there is not
+generally a mapping back from the result of the constructor or method to its
+parameters.
+
+## When parameter names are unavailable
+
+AutoBuilder depends on knowing the names of parameters. But parameter names are
+not always available in Java. They _are_ available in these cases, at least:
+
+* In code that is being compiled at the same time as the `@AutoBuilder` class
+ or interface.
+* In _records_ (from Java 16 onwards).
+* In the constructors of Kotlin data classes.
+* In code that was compiled with the [`-parameters`] option.
+
+A Java compiler bug means that parameter names are not available to AutoBuilder
+when compiling with JDK versions before 11, in any of these cases except the
+first. We recommend building with a recent JDK, using the `--release` option if
+necessary to produce code that can run on earlier versions.
+
+If parameter names are unavailable, you always have the option of introducing a
+static method in the same class as the `@AutoBuilder` type, and having it call
+the method you want. Since it is compiled at the same time, its parameter names
+are available.
+
+Here's an example of fixing a problem this way. The code here typically will not
+compile, since parameter names of JDK methods are not available:
+
+```
+import java.time.LocalTime;
+
+public class TimeUtils {
+ // Does not work, since parameter names from LocalTime.of are unavailable.
+ @AutoBuilder(callMethod = "of", ofClass = LocalTime.class)
+ public interface TimeBuilder {
+ TimeBuilder setHour(int x);
+ TimeBuilder setMinute(int x);
+ TimeBuilder setSecond(int x);
+ LocalTime build();
+ }
+}
+```
+
+It will produce an error message like this:
+
+```
+error: [AutoBuilderNoMatch] Property names do not correspond to the parameter names of any static method named "of":
+ public interface TimeBuilder {
+ ^
+ of(int arg0, int arg1)
+ of(int arg0, int arg1, int arg2)
+ of(int arg0, int arg1, int arg2, int arg3)
+```
+
+The names `arg0`, `arg1`, etc are concocted by the compiler because it doesn't
+have the real names.
+
+Introducing a static method fixes the problem:
+
+```
+import java.time.LocalTime;
+
+public class TimeUtils {
+ static LocalTime localTimeOf(int hour, int second, int second) {
+ return LocalTime.of(hour, minute, second);
+ }
+
+ @AutoBuilder(callMethod = "localTimeOf")
+ public interface TimeBuilder {
+ TimeBuilder setHour(int x);
+ TimeBuilder setMinute(int x);
+ TimeBuilder setSecond(int x);
+ LocalTime build();
+ }
+}
+```
+
+[`-parameters`]: https://docs.oracle.com/en/java/javase/16/docs/specs/man/javac.html#option-parameters
diff --git a/value/userguide/builders-howto.md b/value/userguide/builders-howto.md
index 00038e7..e7cf537 100644
--- a/value/userguide/builders-howto.md
+++ b/value/userguide/builders-howto.md
@@ -32,6 +32,8 @@
* ... [offer **both** accumulation and set-at-once methods for the same
collection-valued property?](#collection_both)
* ... [access nested builders while building?](#nested_builders)
+* ... [create a "step builder"?](#step)
+* ... [create a builder for something other than an `@AutoValue`?](#autobuilder)
## <a name="beans"></a>... use (or not use) `set` prefixes?
@@ -79,10 +81,13 @@
[Optional](#optional) it will default to an empty `Optional` as you might also
expect. But if it isn't either of those things (including if it is a
primitive-valued property, which *can't* be null), then `build()` will throw an
-unchecked exception.
+unchecked exception. This includes collection properties, which must be given a
+value. They don't default to empty unless there is a
+[collection builder](#accumulate).
-But this presents a problem, since one of the main *advantages* of a builder in
-the first place is that callers can specify only the properties they care about!
+But this requirement to supply a value presents a problem, since one of the main
+*advantages* of a builder in the first place is that callers can specify only
+the properties they care about!
The solution is to provide a default value for such properties. Fortunately this
is easy: just set it on the newly-constructed builder instance before returning
@@ -306,7 +311,8 @@
`Optional` without needing to [specify](#default) a default explicitly. And,
instead of or as well as the normal `setFoo(Optional<String>)` method, you can
have `setFoo(String)`. Then `setFoo(s)` is equivalent to
-`setFoo(Optional.of(s))`.
+`setFoo(Optional.of(s))`. (If it is `setFoo(@Nullable String)`, then `setFoo(s)`
+is equivalent to `setFoo(Optional.ofNullable(s))`.)
Here, `Optional` means either [`java.util.Optional`] from Java (Java 8 or
later), or [`com.google.common.base.Optional`] from Guava. Java 8 also
@@ -419,7 +425,22 @@
`getCountries()` convention, the builder method must be `countriesBuilder()`
and not `getCountriesBuilder()`.
-You may notice a small problem with this example: the caller can no longer
+It's also possible to have a method like `countriesBuilder` with a single
+argument, provided that the `Builder` class has a public constructor or a
+static `builder` method, with one parameter that the argument can be assigned
+to. For example, if `countries()` were an `ImmutableSortedSet<String>` and you
+wanted to supply a `Comparator` to `ImmutableSortedSet.Builder`, you could
+write:
+
+```java
+ public abstract ImmutableSortedSet.Builder<String>
+ countriesBuilder(Comparator<String> comparator);
+```
+
+That works because `ImmutableSortedSet.Builder` has a constructor that
+accepts a `Comparator` parameter.
+
+You may notice a small problem with these examples: the caller can no longer
create their instance in a single chained statement:
```java
@@ -598,5 +619,21 @@
be set as if by `speciesBuilder().build()`. In the example, that would result
in an exception because the required properties of `Species` have not been set.
+## <a name="step"></a>... create a "step builder"?
+
+A [_step builder_](http://rdafbn.blogspot.com/2012/07/step-builder-pattern_28.html)
+is a collection of builder interfaces that take you step by step through the
+setting of each of a list of required properties. We think that these are a nice
+idea in principle but not necessarily in practice. Regardless, if you want to
+use AutoValue to implement a step builder,
+[this example](https://github.com/google/auto/issues/1000#issuecomment-792875738)
+shows you how.
+
+## <a name="autobuilder"></a> ... create a builder for something other than an `@AutoValue`?
+
+Sometimes you want to make a builder like the kind described here, but have it
+build something other than an `@AutoValue` class, or even call a static method.
+In that case you can use `@AutoBuilder`. See
+[its documentation](autobuilder.md).
[protobuf]: https://developers.google.com/protocol-buffers/docs/reference/java-generated#builders
diff --git a/value/userguide/builders.md b/value/userguide/builders.md
index 11c68c6..1de6bfa 100644
--- a/value/userguide/builders.md
+++ b/value/userguide/builders.md
@@ -10,15 +10,14 @@
Note that we recommend reading and understanding the basic usage shown in the
[introduction](index.md) first.
-
-## How to use AutoValue with Builders<a name="howto"></a>
+## How to use AutoValue with Builders <a name="howto"></a>
As explained in the introduction, the AutoValue concept is that **you write an
abstract value class, and AutoValue implements it**. Builder generation works in
the exact same way: you also create an abstract builder class, nesting it inside
your abstract value class, and AutoValue generates implementations for both.
-### In `Animal.java`<a name="example_java"></a>
+### In `Animal.java` <a name="example_java"></a>
```java
import com.google.auto.value.AutoValue;
@@ -45,7 +44,7 @@
have **Javadoc**. We're leaving these off in the User Guide only to keep the
examples clean and short.
-### Usage<a name="usage"></a>
+### Usage <a name="usage"></a>
```java
public void testAnimal() {
@@ -65,12 +64,12 @@
}
```
-### What does AutoValue generate?<a name="generated"></a>
+### What does AutoValue generate? <a name="generated"></a>
For the `Animal` example shown above, here is [typical code AutoValue might
generate](generated-builder-example.md).
-## Warnings<a name="warnings"></a>
+## Warnings <a name="warnings"></a>
Be sure to put the static `builder()` method directly in your value class (e.g.,
`Animal`) and not the nested abstract `Builder` class. That ensures that the
@@ -92,10 +91,16 @@
time?](builders-howto.md#normalize)
* ... [expose **both** a builder and a factory
method?](builders-howto.md#both)
+* ... [handle `Optional` properties?](builders-howto.md#optional)
* ... [use a **collection**-valued property?](builders-howto.md#collection)
* ... [let my builder **accumulate** values for a collection-valued
property (not require them all at once)?](builders-howto.md#accumulate)
* ... [accumulate values for a collection-valued property, without
- **breaking the chain**?](builders-howto.md#add)
+ **"breaking the chain"**?](builders-howto.md#add)
* ... [offer **both** accumulation and set-at-once methods for the same
collection-valued property?](builders-howto.md#collection_both)
+* ... [access nested builders while
+ building?](builders-howto.md#nested_builders)
+* ... [create a "step builder"?](builders-howto.md#step)
+* ... [create a builder for something other than an
+ `@AutoValue`?](builders-howto.md#autobuilder)
diff --git a/value/userguide/extensions.md b/value/userguide/extensions.md
index ec6c467..6acb3ca 100644
--- a/value/userguide/extensions.md
+++ b/value/userguide/extensions.md
@@ -9,7 +9,6 @@
Each extension is a class. If that class is on the `processorpath` when you
compile your `@AutoValue` class, the extension can run.
-
Some extensions are triggered by their own annotations, which you add to your
class; others may be triggered in other ways. Consult the extension's
documentation for usage instructions.
@@ -40,4 +39,3 @@
[AutoService]: https://github.com/google/auto/tree/master/service
[`AutoValueExtension`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/AutoValueExtension.java
[`ServiceLoader`]: http://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html
-
diff --git a/value/userguide/howto.md b/value/userguide/howto.md
index 6f9142c..c451185 100644
--- a/value/userguide/howto.md
+++ b/value/userguide/howto.md
@@ -42,6 +42,7 @@
* ... [make a class where only one of its properties is ever set?](#oneof)
* ... [copy annotations from a class/method to the implemented
class/method/field?](#copy_annotations)
+* ... [create a **pretty string** representation?](#toprettystring)
## <a name="builder"></a>... also generate a builder for my value class?
@@ -239,16 +240,16 @@
abstract class IgnoreExample {
static IgnoreExample create(String normalProperty, String ignoredProperty) {
IgnoreExample ie = new AutoValue_IgnoreExample(normalProperty);
- ie.ignoredProperty = ignoredProperty;
+ ie.ignoredProperty.set(ignoredProperty);
return ie;
}
abstract String normalProperty();
- private String ignoredProperty; // sadly, it can't be `final`
+ private final AtomicReference<String> ignoredProperty = new AtomicReference<>();
final String ignoredProperty() {
- return ignoredProperty;
+ return ignoredProperty.get();
}
}
```
@@ -256,6 +257,11 @@
Note that this means the field is also ignored by `toString`; to AutoValue
it simply doesn't exist.
+Note that we use `AtomicReference<String>` to ensure that other threads will
+correctly see the value that was written. You could also make the field
+`volatile`, or use `synchronized` (`synchronized (ie)` around the assignment and
+`synchronized` on the `ignoredProperty()` method).
+
## <a name="supertypes"></a>... have AutoValue also implement abstract methods from my supertypes?
AutoValue will recognize every abstract accessor method whether it is defined
@@ -347,7 +353,6 @@
arrays, they can be replaced with a proper `List` implementation for very little
added cost.
-
If it's important to accept an object array at construction time, refer to the
*first* example shown [here](#mutable_property).
@@ -676,3 +681,44 @@
[`@AutoValue.CopyAnnotations`]: http://static.javadoc.io/com.google.auto.value/auto-value/1.6/com/google/auto/value/AutoValue.CopyAnnotations.html
+## <a name="toprettystring"></a>... create a pretty string representation?
+
+If you have a value class with a long `toString()` representation, annotate a
+method with [`@ToPrettyString`] and AutoValue will generate an implementation that
+returns a pretty String rendering of the instance. For example:
+
+```java
+@AutoValue
+abstract class Song {
+ abstract String lyrics();
+ abstract List<Artist> artists();
+
+ @ToPrettyString
+ abstract String toPrettyString();
+}
+```
+
+Below is a sample rendering of the result of calling `toPrettyString()`.
+
+```
+Song {
+ lyrics = I'm off the deep end, watch as I dive in
+ I'll never meet the ground
+ Crash through the surface, where they can't hurt us
+ We're far from the shallow now.,
+ artists = [
+ Artist {
+ name = Lady Gaga,
+ },
+ Artist {
+ name = Bradley Cooper,
+ }
+ ],
+}
+```
+
+`@ToPrettyString` can be used on the default `toString()` to override the
+default AutoValue-generated `toString()` implementation, or on another
+user-defined method.
+
+[`@ToPrettyString`]: https://github.com/google/auto/blob/master/value/src/main/java/com/google/auto/value/extension/toprettystring/ToPrettyString.java
diff --git a/value/userguide/index.md b/value/userguide/index.md
index 2e05d54..d6ef95c 100644
--- a/value/userguide/index.md
+++ b/value/userguide/index.md
@@ -13,7 +13,6 @@
>
> -- *Joshua Bloch, author, Effective Java*
-
## <a name="background"></a>Background
**Value classes** are extremely common in Java projects. These are classes for
@@ -150,18 +149,18 @@
```groovy
dependencies {
- // Use 'api' rather than 'compile' for Android or java-library projects.
- compile "com.google.auto.value:auto-value-annotations:${autoValueVersion}"
+ compileOnlyApi "com.google.auto.value:auto-value-annotations:${autoValueVersion}"
annotationProcessor "com.google.auto.value:auto-value:${autoValueVersion}"
}
```
-Note: If you are using a version of Gradle prior to 4.6, you must apply an
-annotation processing plugin [as described in these instructions][tbroyer-apt].
+Note: If you are using a version of Gradle prior to 6.7, use `compile` or (for
+Android or java-library projects) `api` instead of `compileOnlyApi`. If you are
+using a version prior to 4.6, you must apply an annotation processing plugin
+[as described in these instructions][tbroyer-apt].
[tbroyer-apt]: https://plugins.gradle.org/plugin/net.ltgt.apt
-
### <a name="usage"></a>Usage
Your choice to use AutoValue is essentially *API-invisible*. This means that, to
@@ -276,13 +275,7 @@
set?](howto.md#oneof)
* ... [copy annotations from a class/method to the implemented
class/method/field?](howto.md#copy_annotations)
+* ... [create a **pretty string** representation?](howto.md#toprettystring)
+
<!-- TODO(kevinb): should the above be only a selected subset? -->
-
-## <a name="more"></a>More information
-
-See the links in the sidebar at the top left.
-
-<!-- TODO(kevinb): there are some tidbits of information that don't seem to
- belong anywhere yet; such as how it implements floating-point equality -->
-
diff --git a/value/userguide/practices.md b/value/userguide/practices.md
index 0121bd8..e78c6e5 100644
--- a/value/userguide/practices.md
+++ b/value/userguide/practices.md
@@ -1,7 +1,6 @@
# Best practices
-
## <a name="interchangeable"></a>"Equals means interchangeable"
Don't use AutoValue to implement value semantics unless you really want value
diff --git a/value/userguide/why.md b/value/userguide/why.md
index 603abb8..40c994f 100644
--- a/value/userguide/why.md
+++ b/value/userguide/why.md
@@ -15,5 +15,4 @@
[slide presentation] compares AutoValue to numerous alternatives and explains
why we think it is better.
-
[slide presentation]: https://docs.google.com/presentation/d/14u_h-lMn7f1rXE1nDiLX0azS3IkgjGl5uxp5jGJ75RE/edit
