`@Inherited` annotations are ignored on subclasses

[Vampire]

I use Jandex in a Weld SE project.
Jandex does not discover subclasses of classes with @Inherited bean-defining annotations.

I tested with a play Gradle project that only has weld-se-core as implementation dependency and jandex as runtimeOnly dependeny (or not, depending on tested case).

I tested with weld-se-core 4.0.3.Final and jandex 2.4.5.Final as well as weld-se-core 6.0.3.Final and jandex 3.5.3, both combinations show the same faulty behavior.

The only source file in the play project is Foo.java with content

package foo;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.context.Initialized;
import jakarta.enterprise.event.Observes;
import jakarta.enterprise.inject.Instance;
import jakarta.enterprise.inject.Vetoed;
import jakarta.enterprise.inject.se.SeContainerInitializer;
import jakarta.inject.Inject;

import static java.lang.Boolean.FALSE;
import static java.lang.Boolean.TRUE;

public class Foo {
    public static void main(String[] args) {
        SeContainerInitializer.newInstance()
                .addProperty("jakarta.enterprise.inject.scan.implicit", TRUE)
                .addProperty("org.jboss.weld.construction.relaxed", FALSE)
                .initialize();
    }
}

@ApplicationScoped
class Main {
    @Inject
    Instance<Bar> bars;

    void ensureInitializationAtStartup(@Observes @Initialized(ApplicationScoped.class) Object event) {
        bars.stream().map(Bar::getRealClass).forEach(System.out::println);
    }
}

interface Bar {
    Class<?> getRealClass();
}

//@Vetoed
@ApplicationScoped
class Baz implements Bar {
    void ensureInitializationAtStartup(@Observes @Initialized(ApplicationScoped.class) Object event) {
    }

    @Override
    public Class<?> getRealClass() {
        return getClass();
    }
}

//@ApplicationScoped
class Bam extends Baz {}

Without @Vetoed and without Jandex, I get both classes.
Without @Vetoed and with Jandex, I only get the superclass.
With @Vetoed but without Jandex I only get the the subclass.
With @Vetoed and Jandex I get neither class.
With @Vetoed on the superclass and @ApplicationScoped on both and without Jandex, I get only the subclass.
With @Vetoed on the superclass and @ApplicationScoped on both and with Jandex, I also get only the subclass.

So my conclusion is, that Jandex does not consider the @Inherited @ApplicationScoped annotation on the superclass.

[Ladicek]

What you're describing seems like a misuse of Jandex in Weld, but I can't say I understand exactly. CC @manovotn in any case, as I believe this is a Weld issue. Most likely in the CDI SE implementation, because that's IIRC the only place Weld does type discovery on its own.

[manovotn]

This does not seem to be a Jandex fault.

First and foremost @Vampire, if what you describe is the actual behavior (I am testing it as we speak), then it is actually the Jandex behavior that would be wrong.
Your class Bam extends Baz {} should in fact not be dicovered during annotated discovery mode.
The spec says that only beans with bean defining annotations are discovered:

If one of these annotations is declared on a bean class, then the bean class is said to have a bean defining annotation.

The @Vetoed annotation should bear no meaning here as the bean needs to have some form of BDA to be discovered, the inheritance alone won't do and is only used for when the bean is discovered and you then search superclasses for these to configure bean attributes.

[manovotn]

FTR, I have managed to reproduce the behavior (minus the @Vetoed which I think doesn't have any value/meaning here).
I will investigate further and report back with a Weld JIRA issue as well once I know more.

[Vampire]

I'm a bit confused, you say "does not seem to be a Jandex fault" and in the next sentence "then it is actually the Jandex behavior that would be wrong", that's a bit contradicting, isn't it?

Your class Bam extends Baz {} should in fact not be dicovered during annotated discovery mode.
The spec says that only beans with bean defining annotations are discovered:

But @ApplicationScoped is declared @Inherited.
So shouldn't Bam be considered as having the annotation as it is inherited from the superclass?
Otherwise it would not make much sense that @ApplicationScoped is declared @Inherited.

[Vampire]

The @Vetoed behavior as I said is correct I think, as that one is not declared @Inherited.

[Ladicek]

But @ApplicationScoped is declared @Inherited. So shouldn't Bam be considered as having the annotation as it is inherited from the superclass? Otherwise it would not make much sense that @ApplicationScoped is declared @Inherited.

That is not how annotated type discovery works in CDI. The class has to have a bean defining annotation to be discovered. (Note that bean defining annotations don't necessarily have to be scope annotations -- stereotypes are also bean defining annotations.)

Note that this has changed in CDI 4.0, where annotated discovery became the default. Previously, the "all" discovery was default, and presence of bean defining annotations was not required.

[Vampire]

I know and understand that bean-defining annotation is necessary for the class to be a CDI bean with annotation discorvery.

But again, @ApplicationScoped is declared to be @Inherited.
So the subclass does have the bean-defining annotation through inheritance, doesn't it?

That's probably also why non-Jandex discovery does discover the bean, because of if you ask the subclass for the annotation, you will get it returned, because it is @Inherited.

[manovotn]

I'm a bit confused, you say "does not seem to be a Jandex fault" and in the next sentence "then it is actually the Jandex behavior that would be wrong", that's a bit contradicting, isn't it?

Sorry, meant to say that it is the Jandex behavior that would be correct as opposed to the reflection strategy.
Bam should not be discovered as a bean as it doesn't declare any bean defining annotation itself. The inheritance alone is no sufficient.

But @ApplicationScoped is declared @Inherited.
So shouldn't Bam be considered as having the annotation as it is inherited from the superclass?
Otherwise it would not make much sense that @ApplicationScoped is declared @Inherited.

INheritance is only useful once the class has been marked as a bean.
This can be useful for instance because there are multiple ways of discovering a bean that have nothing to do with scopes - stereotypes or adding it explicitly via extension to name some - and in such case you can still inherit the scope.

[Ladicek]

What does it mean for a class to have a bean defining annotation is actually not "intuitively understood", it's specified in https://jakarta.ee/specifications/cdi/4.1/jakarta-cdi-spec-4.1.html#bean_defining_annotations It says:

The set of bean defining annotations contains:

• ...

If one of these annotations is declared on a bean class, then the bean class is said to have a bean defining annotation.

So, for a class to have a bean defining annotation, the annotation has to be declared on the class.

[manovotn]

Indeed, I quoted that in part in #633 (comment) but I could have been more verbose.

Here is the WELD JIRA https://issues.redhat.com/browse/WELD-2826
And here's a PR proposal that I have so far - https://issues.redhat.com/browse/WELD-2826

@Ladicek feel free to close this issue as it's not a Jandex problem.

[Vampire]

Ok, thanks for the clarifications and sorry for the noise then.

Even those words would be a bit ambiguous to me, but the spec even has an explicit example that shows a subclass and defines that it does not have a bean-defining annotation. 🙈

[manovotn]

Ok, thanks for the clarifications and sorry for the noise then.

Nothing to be sorry for, just one more bug you helped us squash :)