From dec3bf0ec7b72d9cec9f92b497570bc46590a65d Mon Sep 17 00:00:00 2001 From: Brad Corso Date: Thu, 3 Jun 2021 07:52:09 -0700 Subject: Add String and TypeElement versions of auto-common APIs that currently take in Class. These changes continue the effort to move away from referencing classes from the user API directly in processors, which can cause issues especially with Android dependencies. Note: I decided not to do anything with isTypeOf yet because I'm not sure of a great way to support that. RELNOTES=Add String and TypeElement versions of auto-common APIs that currently take in Class. PiperOrigin-RevId: 377287397 --- .../google/auto/common/AnnotationMirrorsTest.java | 54 +++++++++++ .../com/google/auto/common/MoreElementsTest.java | 101 +++++++++++++++------ 2 files changed, 126 insertions(+), 29 deletions(-) (limited to 'common/src/test/java') 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 b1a0a152..363fd24b 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.common.truth.Truth.assertThat; 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; @@ -252,4 +257,53 @@ public class AnnotationMirrorsTest { private AnnotationMirror annotationOn(Class clazz) { 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 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/MoreElementsTest.java b/common/src/test/java/com/google/auto/common/MoreElementsTest.java index de33c567..0677a7a0 100644 --- a/common/src/test/java/com/google/auto/common/MoreElementsTest.java +++ b/common/src/test/java/com/google/auto/common/MoreElementsTest.java @@ -58,13 +58,14 @@ public class MoreElementsTest { @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()); @@ -94,15 +95,14 @@ public class MoreElementsTest { @Test public void asTypeElement() { - Element typeElement = compilation.getElements().getTypeElement(String.class.getCanonicalName()); + 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()); + TypeElement typeElement = elements.getTypeElement(String.class.getCanonicalName()); for (ExecutableElement e : ElementFilter.methodsIn(typeElement.getEnclosedElements())) { assertFalse(MoreElements.isType(e)); try { @@ -194,27 +194,76 @@ public class MoreElementsTest { @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()); - - Optional documented = - MoreElements.getAnnotationMirror(element, Documented.class); - Optional innerAnnotation = - MoreElements.getAnnotationMirror(element, InnerAnnotation.class); - Optional suppressWarnings = - MoreElements.getAnnotationMirror(element, SuppressWarnings.class); - + elements.getTypeElement(AnnotatedAnnotation.class.getCanonicalName()); + + // 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 documented, + Optional innerAnnotation, + Optional suppressWarnings) { expect.that(documented).isPresent(); expect.that(innerAnnotation).isPresent(); expect.that(suppressWarnings).isAbsent(); @@ -265,7 +314,6 @@ public class MoreElementsTest { @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); @@ -290,7 +338,6 @@ public class MoreElementsTest { @Test public void getLocalAndInheritedMethods() { - Elements elements = compilation.getElements(); Types types = compilation.getTypes(); TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT); TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG); @@ -314,7 +361,6 @@ public class MoreElementsTest { @Test public void getAllMethods() { - Elements elements = compilation.getElements(); Types types = compilation.getTypes(); TypeMirror intMirror = types.getPrimitiveType(TypeKind.INT); TypeMirror longMirror = types.getPrimitiveType(TypeKind.LONG); @@ -365,10 +411,9 @@ public class MoreElementsTest { // Example from https://github.com/williamlian/daggerbug @Test public void getLocalAndInheritedMethods_DaggerBug() { - Elements elementUtils = compilation.getElements(); - TypeElement main = elementUtils.getTypeElement(Main.ParentComponent.class.getCanonicalName()); + TypeElement main = elements.getTypeElement(Main.ParentComponent.class.getCanonicalName()); Set methods = - MoreElements.getLocalAndInheritedMethods(main, compilation.getTypes(), elementUtils); + MoreElements.getLocalAndInheritedMethods(main, compilation.getTypes(), elements); assertThat(methods).hasSize(1); ExecutableElement method = methods.iterator().next(); assertThat(method.getSimpleName().toString()).isEqualTo("injectable"); @@ -414,7 +459,7 @@ public class MoreElementsTest { } 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())) { @@ -468,8 +513,6 @@ public class MoreElementsTest { // are implemented in AbstractList. @Test public void getLocalAndInheritedMethods_AbstractList() { - Elements elements = compilation.getElements(); - TypeElement abstractType = elements.getTypeElement(AbstractAbstractList.class.getCanonicalName()); Set abstractTypeMethods = -- cgit v1.2.3