WELD-2831 Fix firing of ProcessSyntheticAnnotatedType for types added via configurators

impl/src/main/java/org/jboss/weld/bootstrap/events/AbstractAnnotatedTypeRegisteringEvent.java

@@ -24,6 +24,7 @@
 import jakarta.enterprise.context.spi.Context;
 import jakarta.enterprise.inject.spi.AnnotatedType;
 import jakarta.enterprise.inject.spi.DefinitionException;
+import jakarta.enterprise.inject.spi.Extension;
 
 import org.jboss.weld.annotated.AnnotatedTypeValidator;
 import org.jboss.weld.bootstrap.BeanDeployment;
@@ -45,22 +46,24 @@ protected AbstractAnnotatedTypeRegisteringEvent(BeanManagerImpl beanManager, Typ
         this.additionalAnnotatedTypes = new LinkedList<>();
     }
 
-    protected void addSyntheticAnnotatedType(AnnotatedType<?> type, String id) {
+    protected void addSyntheticAnnotatedType(AnnotatedType<?> type, String id, Extension extension) {
         AnnotatedTypeValidator.validateAnnotatedType(type);
         if (type.getJavaClass().isAnnotation() || Beans.isVetoed(type)) {
             return;
         }
-        storeSyntheticAnnotatedType(getOrCreateBeanDeployment(type.getJavaClass()), type, id);
+        storeSyntheticAnnotatedType(getOrCreateBeanDeployment(type.getJavaClass()), type, id, extension);
     }
 
-    protected void storeSyntheticAnnotatedType(BeanDeployment deployment, AnnotatedType<?> type, String id) {
-        deployment.getBeanDeployer().addSyntheticClass(type, getReceiver(), id);
+    protected void storeSyntheticAnnotatedType(BeanDeployment deployment, AnnotatedType<?> type, String id,
+            Extension extension) {
+        deployment.getBeanDeployer().addSyntheticClass(type, extension, id);
     }
 
     protected void finish() {
         try {
             for (AnnotatedTypeRegistration<?> annotatedTypeRegistration : additionalAnnotatedTypes) {
-                addSyntheticAnnotatedType(annotatedTypeRegistration.configurator.complete(), annotatedTypeRegistration.id);
+                addSyntheticAnnotatedType(annotatedTypeRegistration.configurator.complete(), annotatedTypeRegistration.id,
+                        annotatedTypeRegistration.extension);
             }
         } catch (Exception e) {
             throw new DefinitionException(e);
@@ -73,9 +76,14 @@ protected static class AnnotatedTypeRegistration<T> {
 
         private final String id;
 
-        AnnotatedTypeRegistration(AnnotatedTypeConfiguratorImpl<T> configurator, String id) {
+        // store Extension reference - creation of synth. AT from configurators happens *after* we notify observers
+        // at that point, the getReceiver() method already returns null and we would not detect the AT as synthetic
+        private final Extension extension;
+
+        AnnotatedTypeRegistration(AnnotatedTypeConfiguratorImpl<T> configurator, String id, Extension extension) {
             this.configurator = configurator;
             this.id = id;
+            this.extension = extension;
         }
 
     }

impl/src/main/java/org/jboss/weld/bootstrap/events/AfterTypeDiscoveryImpl.java

@@ -83,7 +83,7 @@ public List<Class<?>> getDecorators() {
     @Override
     public void addAnnotatedType(AnnotatedType<?> type, String id) {
         checkWithinObserverNotification();
-        addSyntheticAnnotatedType(type, id);
+        addSyntheticAnnotatedType(type, id, getReceiver());
         BootstrapLogger.LOG.addAnnotatedTypeCalled(getReceiver(), type);
     }
 
@@ -92,14 +92,14 @@ public <T> AnnotatedTypeConfigurator<T> addAnnotatedType(Class<T> type, String i
         checkWithinObserverNotification();
         AnnotatedTypeConfiguratorImpl<T> configurator = new AnnotatedTypeConfiguratorImpl<>(
                 getBeanManager().createAnnotatedType(type));
-        additionalAnnotatedTypes.add(new AnnotatedTypeRegistration<T>(configurator, id));
+        additionalAnnotatedTypes.add(new AnnotatedTypeRegistration<T>(configurator, id, getReceiver()));
         return configurator;
     }
 
     @Override
-    protected void storeSyntheticAnnotatedType(BeanDeployment deployment, AnnotatedType<?> type, String id) {
+    protected void storeSyntheticAnnotatedType(BeanDeployment deployment, AnnotatedType<?> type, String id,
+            Extension extension) {
         SlimAnnotatedType<?> annotatedType = transformer.getUnbackedAnnotatedType(type, getBeanManager().getId(), id);
-        Extension extension = getReceiver();
         SlimAnnotatedTypeContext<?> annotatedTypeContext = SlimAnnotatedTypeContext.of(annotatedType, extension);
 
         ProcessAnnotatedTypeImpl<?> event = events.fireProcessAnnotatedType(getBeanManager(), annotatedTypeContext);

impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java

@@ -117,7 +117,7 @@ public void addStereotype(Class<? extends Annotation> stereotype, Annotation...
     @Override
     public void addAnnotatedType(AnnotatedType<?> type, String id) {
         checkWithinObserverNotification();
-        addSyntheticAnnotatedType(type, id);
+        addSyntheticAnnotatedType(type, id, getReceiver());
         BootstrapLogger.LOG.addAnnotatedTypeCalledInBBD(getReceiver(), type);
     }
 
@@ -126,7 +126,7 @@ public <T> AnnotatedTypeConfigurator<T> addAnnotatedType(Class<T> type, String i
         checkWithinObserverNotification();
         AnnotatedTypeConfiguratorImpl<T> configurator = new AnnotatedTypeConfiguratorImpl<>(
                 getBeanManager().createAnnotatedType(type));
-        additionalAnnotatedTypes.add(new AnnotatedTypeRegistration<T>(configurator, id));
+        additionalAnnotatedTypes.add(new AnnotatedTypeRegistration<T>(configurator, id, getReceiver()));
         BootstrapLogger.LOG.addAnnotatedTypeCalledInBBD(getReceiver(), type);
         return configurator;
     }

tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/Banana.java

@@ -0,0 +1,4 @@
+package org.jboss.weld.tests.extensions.lifecycle.processSyntheticAnnotatedType;
+
+public class Banana {
+}

tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/Kiwi.java

@@ -0,0 +1,4 @@
+package org.jboss.weld.tests.extensions.lifecycle.processSyntheticAnnotatedType;
+
+public class Kiwi {
+}

tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/ProcessSyntheticAnnotatedTypeTest.java

@@ -50,7 +50,7 @@ public static Archive<?> getDeployment() {
                 .create(BeanArchive.class, Utils.getDeploymentNameAsHash(ProcessSyntheticAnnotatedTypeTest.class))
                 .addPackage(Juicy.class.getPackage())
                 .addAsServiceProvider(Extension.class, RegisteringExtension1.class, RegisteringExtension2.class,
-                        ModifyingExtension.class, VerifyingExtension.class);
+                        RegisteringExtension3.class, ModifyingExtension.class, VerifyingExtension.class);
     }
 
     @Test
@@ -60,10 +60,15 @@ public void testEventsFired() {
         assertTrue(psatClasses.contains(Orange.class));
         assertTrue(psatClasses.contains(Apple.class));
         assertTrue(psatClasses.contains(Pear.class));
+        assertTrue(psatClasses.contains(Kiwi.class));
+        assertTrue(psatClasses.contains(Banana.class));
         // also verify that PAT is fired for classes in a BDA
         assertTrue(patClasses.contains(Orange.class));
         assertTrue(patClasses.contains(Apple.class));
         assertTrue(patClasses.contains(Pear.class));
+        // Kiwi and Banana have no annotations
+        assertFalse(patClasses.contains(Kiwi.class));
+        assertFalse(patClasses.contains(Banana.class));
     }
 
     @Test
@@ -72,6 +77,8 @@ public void testSource() {
         assertTrue(sources.get(Apple.class) instanceof RegisteringExtension1);
         assertTrue(sources.get(Orange.class) instanceof RegisteringExtension1);
         assertTrue(sources.get(Pear.class) instanceof RegisteringExtension2);
+        assertTrue(sources.get(Kiwi.class) instanceof RegisteringExtension3);
+        assertTrue(sources.get(Banana.class) instanceof RegisteringExtension3);
     }
 
     @Test
@@ -89,5 +96,8 @@ public void testChangesApplied(BeanManager manager) {
         assertEquals(2, manager.getBeans(Pear.class, Any.Literal.INSTANCE).size());
         Set<Bean<?>> juicyPears = manager.getBeans(Pear.class, Juicy.Literal.INSTANCE);
         assertEquals(1, juicyPears.size());
+
+        assertEquals(1, manager.getBeans(Kiwi.class, Juicy.Literal.INSTANCE).size());
+        assertEquals(1, manager.getBeans(Banana.class, Fresh.Literal.INSTANCE).size());
     }
 }

tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/RegisteringExtension3.java

@@ -0,0 +1,19 @@
+package org.jboss.weld.tests.extensions.lifecycle.processSyntheticAnnotatedType;
+
+import jakarta.enterprise.event.Observes;
+import jakarta.enterprise.inject.spi.AfterTypeDiscovery;
+import jakarta.enterprise.inject.spi.BeforeBeanDiscovery;
+import jakarta.enterprise.inject.spi.Extension;
+
+public class RegisteringExtension3 implements Extension {
+
+    // using BBD
+    void registerJuicyKiwi(@Observes BeforeBeanDiscovery event) {
+        event.addAnnotatedType(Kiwi.class, Kiwi.class.getSimpleName() + "Configured").add(Juicy.Literal.INSTANCE);
+    }
+
+    // using ATD
+    void registerFreshBanana(@Observes AfterTypeDiscovery event) {
+        event.addAnnotatedType(Banana.class, Banana.class.getSimpleName() + "Configured").add(Fresh.Literal.INSTANCE);
+    }
+}