ArC: remove incorrect annotation literals for memberless annotations

Author: Ladicek

independent-projects/arc/processor/src/test/java/io/quarkus/arc/processor/AnnotationLiteralProcessorTest.java

@@ -379,8 +379,12 @@ public void memberless() throws ReflectiveOperationException {
         assertEquals(incorrectLiteral, annotation);
         assertEquals(annotation, incorrectLiteral);
 
+        assertEquals(correctLiteral, incorrectLiteral);
+        assertEquals(incorrectLiteral, correctLiteral);
+
         assertEquals(correctLiteral.hashCode(), annotation.hashCode());
         assertEquals(incorrectLiteral.hashCode(), annotation.hashCode());
+        assertEquals(correctLiteral.hashCode(), incorrectLiteral.hashCode());
 
         assertEquals("@io.quarkus.arc.processor.AnnotationLiteralProcessorTest$MemberlessAnnotation()",
                 annotation.toString());

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/MyQualifier.java

@@ -10,12 +10,14 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
+import jakarta.enterprise.util.AnnotationLiteral;
 import jakarta.inject.Qualifier;
 
 @Qualifier
 @Inherited
 @Target({ TYPE, METHOD, FIELD, PARAMETER })
 @Retention(RUNTIME)
 public @interface MyQualifier {
-
+    class Literal extends AnnotationLiteral<MyQualifier> implements MyQualifier {
+    }
 }

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/TestLiteral.java

@@ -0,0 +1,8 @@
+package io.quarkus.arc.test;
+
+import jakarta.enterprise.util.AnnotationLiteral;
+
+import org.junit.jupiter.api.Test;
+
+public class TestLiteral extends AnnotationLiteral<Test> implements Test {
+}

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/all/ListAllTest.java

@@ -12,7 +12,6 @@
 import jakarta.annotation.Priority;
 import jakarta.enterprise.context.Dependent;
 import jakarta.enterprise.inject.spi.InjectionPoint;
-import jakarta.enterprise.util.AnnotationLiteral;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 
@@ -23,6 +22,7 @@
 import io.quarkus.arc.InstanceHandle;
 import io.quarkus.arc.test.ArcTestContainer;
 import io.quarkus.arc.test.MyQualifier;
+import io.quarkus.arc.test.TestLiteral;
 
 public class ListAllTest {
 
@@ -52,8 +52,7 @@ public void testSelectAll() {
         assertThatExceptionOfType(IllegalStateException.class)
                 .isThrownBy(() -> bravoHandle.get());
         assertThatExceptionOfType(IllegalArgumentException.class)
-                .isThrownBy(() -> Arc.container().listAll(Service.class, new AnnotationLiteral<Test>() {
-                }));
+                .isThrownBy(() -> Arc.container().listAll(Service.class, new TestLiteral()));
     }
 
     interface Service {

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/beanmanager/BeanManagerTest.java

@@ -189,8 +189,7 @@ public void testResolveInterceptors() {
         assertTrue(interceptors.isEmpty());
         // alpha is @Nonbinding
         interceptors = beanManager.resolveInterceptors(InterceptionType.AROUND_INVOKE, new DummyBinding.Literal(false, true),
-                new AnnotationLiteral<UselessBinding>() {
-                });
+                new UselessBinding.Literal());
         assertEquals(2, interceptors.size());
         assertEquals(DummyInterceptor.class, interceptors.get(0).getBeanClass());
         assertEquals(LowPriorityInterceptor.class, interceptors.get(1).getBeanClass());
@@ -224,8 +223,7 @@ public void testIsScope() {
     public void testResolveObservers() {
         BeanManager beanManager = Arc.container().beanManager();
         Set<ObserverMethod<? super Long>> observers = beanManager.resolveObserverMethods(Long.valueOf(1),
-                new AnnotationLiteral<High>() {
-                });
+                new High.Literal());
         assertEquals(1, observers.size());
         assertEquals(Number.class, observers.iterator().next().getObservedType());
     }
@@ -254,6 +252,8 @@ static class BeanWithCustomQualifier {
     @Documented
     @Qualifier
     public @interface High {
+        class Literal extends AnnotationLiteral<High> implements High {
+        }
     }
 
     @Target({ TYPE, METHOD, PARAMETER, FIELD })
@@ -332,7 +332,7 @@ static class LowFool extends Fool {
         boolean bravo();
 
         @SuppressWarnings("serial")
-        static class Literal extends AnnotationLiteral<DummyBinding> implements DummyBinding {
+        class Literal extends AnnotationLiteral<DummyBinding> implements DummyBinding {
 
             private final boolean alpha;
             private final boolean bravo;
@@ -361,7 +361,8 @@ public boolean bravo() {
     @Documented
     @InterceptorBinding
     public @interface UselessBinding {
-
+        class Literal extends AnnotationLiteral<UselessBinding> implements UselessBinding {
+        }
     }
 
     @DummyBinding(alpha = true, bravo = true)

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/buildextension/observers/ObservertransformerTest.java

@@ -59,8 +59,7 @@ public void testTransformedObserver() {
 
         @SuppressWarnings("serial")
         Event<String> event = Arc.container().beanManager().getEvent().select(String.class,
-                new AnnotationLiteral<AlphaQualifier>() {
-                });
+                new AlphaQualifier.Literal());
         event.fire("foo");
         // Reception was transformed to IF_EXISTS so test1() is not invoked
         assertEquals(List.of("foo_MyObserver2"), MyObserver.EVENTS);
@@ -91,7 +90,8 @@ void test2(@Observes @Priority(10) String event) {
     @Target({ TYPE, METHOD, FIELD, PARAMETER })
     @Retention(RUNTIME)
     public @interface AlphaQualifier {
-
+        class Literal extends AnnotationLiteral<AlphaQualifier> implements AlphaQualifier {
+        }
     }
 
 }

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/decorators/qualifiers/DelegateQualifiersTest.java

@@ -7,7 +7,6 @@
 import jakarta.decorator.Delegate;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.context.Dependent;
-import jakarta.enterprise.util.AnnotationLiteral;
 import jakarta.inject.Inject;
 
 import org.junit.jupiter.api.Test;
@@ -27,8 +26,7 @@ public class DelegateQualifiersTest {
     public void testDecoration() {
         @SuppressWarnings("serial")
         ToUpperCaseConverter converter = Arc.container()
-                .instance(ToUpperCaseConverter.class, new AnnotationLiteral<MyQualifier>() {
-                }).get();
+                .instance(ToUpperCaseConverter.class, new MyQualifier.Literal()).get();
         assertEquals("HOLA!", converter.convert(" holA!"));
         assertEquals(" HOLA!", converter.convertNoDelegation(" holA!"));
     }

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/event/select/EventSelectTest.java

@@ -1,6 +1,5 @@
 package io.quarkus.arc.test.event.select;
 
-import jakarta.enterprise.util.AnnotationLiteral;
 import jakarta.enterprise.util.TypeLiteral;
 
 import org.junit.jupiter.api.Assertions;
@@ -61,17 +60,15 @@ public void testEventSelectWithSubtypeThrowsExceptionForDuplicateBindingType() {
     public void testEventSelectThrowsExceptionIfAnnotationIsNotBindingType() {
         Assertions.assertThrows(IllegalArgumentException.class, () -> {
             SecuritySensor sensor = Arc.container().select(SecuritySensor.class).get();
-            sensor.securityEvent.select(new AnnotationLiteral<NotABindingType>() {
-            });
+            sensor.securityEvent.select(new NotABindingType.Literal());
         }, "Event#select should throw IllegalArgumentException if the annotation is not a binding type.");
     }
 
     @Test
     public void testEventSelectWithSubtypeThrowsExceptionIfAnnotationIsNotBindingType() {
         Assertions.assertThrows(IllegalArgumentException.class, () -> {
             SecuritySensor sensor = Arc.container().select(SecuritySensor.class).get();
-            sensor.securityEvent.select(BreakInEvent.class, new AnnotationLiteral<NotABindingType>() {
-            });
+            sensor.securityEvent.select(BreakInEvent.class, new NotABindingType.Literal());
         }, "Event#select should throw IllegalArgumentException when selecting a subtype and using annotation that is not a binding type.");
     }
 }

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/event/select/NotABindingType.java

@@ -6,8 +6,12 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import jakarta.enterprise.util.AnnotationLiteral;
+
 @Target({ ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD })
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 public @interface NotABindingType {
+    class Literal extends AnnotationLiteral<NotABindingType> implements NotABindingType {
+    }
 }

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/inheritance/QualifiersInheritanceTest.java

@@ -32,8 +32,7 @@ public void testInheritance() {
         // Bravo is not eligible because it has @InheritedQualifier("bravo")
         assertTrue(container.select(SuperBean.class, new InheritedQualifier.Literal("super")).isResolvable());
         // @NonInheritedQualifier is not inherited
-        assertFalse(container.select(SuperBean.class, new AnnotationLiteral<NonInheritedQualifier>() {
-        }).isResolvable());
+        assertFalse(container.select(SuperBean.class, new NonInheritedQualifier.Literal()).isResolvable());
     }
 
     @InheritedQualifier("super")
@@ -84,6 +83,7 @@ public String value() {
     @Qualifier
     @Retention(RUNTIME)
     @interface NonInheritedQualifier {
-
+        class Literal extends AnnotationLiteral<NonInheritedQualifier> implements NonInheritedQualifier {
+        }
     }
 }