diff --git a/impl/src/main/java/org/jboss/weld/bootstrap/events/AbstractAnnotatedTypeRegisteringEvent.java b/impl/src/main/java/org/jboss/weld/bootstrap/events/AbstractAnnotatedTypeRegisteringEvent.java index 22d5e10260f..1ebc44c027e 100644 --- a/impl/src/main/java/org/jboss/weld/bootstrap/events/AbstractAnnotatedTypeRegisteringEvent.java +++ b/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 { private final String id; - AnnotatedTypeRegistration(AnnotatedTypeConfiguratorImpl 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 configurator, String id, Extension extension) { this.configurator = configurator; this.id = id; + this.extension = extension; } } diff --git a/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterTypeDiscoveryImpl.java b/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterTypeDiscoveryImpl.java index 5992d860c01..c0e58e05b07 100644 --- a/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterTypeDiscoveryImpl.java +++ b/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterTypeDiscoveryImpl.java @@ -83,7 +83,7 @@ public List> 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 AnnotatedTypeConfigurator addAnnotatedType(Class type, String i checkWithinObserverNotification(); AnnotatedTypeConfiguratorImpl configurator = new AnnotatedTypeConfiguratorImpl<>( getBeanManager().createAnnotatedType(type)); - additionalAnnotatedTypes.add(new AnnotatedTypeRegistration(configurator, id)); + additionalAnnotatedTypes.add(new AnnotatedTypeRegistration(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); diff --git a/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java b/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java index 2d77429eb4b..5f301d58476 100644 --- a/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java +++ b/impl/src/main/java/org/jboss/weld/bootstrap/events/BeforeBeanDiscoveryImpl.java @@ -117,7 +117,7 @@ public void addStereotype(Class 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 AnnotatedTypeConfigurator addAnnotatedType(Class type, String i checkWithinObserverNotification(); AnnotatedTypeConfiguratorImpl configurator = new AnnotatedTypeConfiguratorImpl<>( getBeanManager().createAnnotatedType(type)); - additionalAnnotatedTypes.add(new AnnotatedTypeRegistration(configurator, id)); + additionalAnnotatedTypes.add(new AnnotatedTypeRegistration(configurator, id, getReceiver())); BootstrapLogger.LOG.addAnnotatedTypeCalledInBBD(getReceiver(), type); return configurator; } diff --git a/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/Banana.java b/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/Banana.java new file mode 100644 index 00000000000..45eebe073fe --- /dev/null +++ b/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 { +} diff --git a/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/Kiwi.java b/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/Kiwi.java new file mode 100644 index 00000000000..7917367cd62 --- /dev/null +++ b/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 { +} diff --git a/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/ProcessSyntheticAnnotatedTypeTest.java b/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/ProcessSyntheticAnnotatedTypeTest.java index ec2920db1d1..84516e8ca97 100644 --- a/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/ProcessSyntheticAnnotatedTypeTest.java +++ b/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> 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()); } } diff --git a/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/RegisteringExtension3.java b/tests-arquillian/src/test/java/org/jboss/weld/tests/extensions/lifecycle/processSyntheticAnnotatedType/RegisteringExtension3.java new file mode 100644 index 00000000000..6f52fdfd716 --- /dev/null +++ b/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); + } +}