What does it mean to observe an event with no qualifiers if all events have #Any as a qualifier? - cdi

Question

The CDI specification says, in section 10.1:
Every event [object] has the qualifier #jakarta.enterprise.inject.Any, even if it does not explicitly declare this qualifier.
(Terminology is important; this is in a part of the spec talking about event objects, i.e. the things you fire, i.e. payloads, that can be observed by observer methods, not the poorly-named Event object, which you use to fire event objects.)
Then in section 10.4.1, talking about observer methods and their parameters, it says:
If the event parameter [of an observer method] does not explicitly declare any qualifier, the observer method observes events with no qualifier.
(This is probably distinguishing this from "ordinary" injection where if you don't put a qualifier on your injection point you get #Default by default; in this case the spec is saying no analogous default applies.)
Leaving aside how observer resolution works (covered in section 10.3), is there any state of affairs where an event object could have no qualifiers, given section 10.1? Or is section 10.4.1 just a statement about what qualifiers are automatically applied to the method parameter (namely none)?

Answer 1

As far as I can interpret the specification, the part from section 10.4.1
If the event parameter [of an observer method] does not explicitly
declare any qualifier, the observer method observes events with no
qualifier.
Makes the third bullet point from section 10.3 come into effect:
if [...] The observer method has no event qualifiers [...]
Therefore, the observer method received the event with the #Any qualifier.

Answer 2

Every event [object] has the qualifier #jakarta.enterprise.inject.Any, even if it does not explicitly declare this qualifier.
This statement is basically a prepping ground for observer resolution (10.3) and is needed in order for the 10.4.1 statement you quoted to work.
Under the hood, there are always qualifiers - at least #Any and this is also an explanation as to why your observer for, say, String type and with "no qualifier" (from user code view) gets notified for every single event of type String regardless the event payload qualifiers.
The spec wordings you quoted are basically a scaffolding allowing CDI to express what happens when user doesn't specify qualifiers all the while actually adding them in the background when appropriate and then performing resolution.
To see what I mean, try experimenting with these observers:
public void observe(#Observes String payload) {
observerTriggered++; // assuming you are counting the triggers...
}
public void observe2(#Observes #Any String payload) {
observerTriggered2++;
}
public void observe3(#Observes #Default String payload) {
observerTriggered3++;
}
public void observe4(#Observes #DummyQualifier("foo") String payload) {
observerTriggered4++;
}
And fire the following events and watch which observers get triggered:
Event<Object> event = // retrieve the event object somehow
event.select(String.class).fire("irrelevantPayload");
event.select(String.class, Any.Literal.INSTANCE).fire("irrelevantPayload");
event.select(String.class, Default.Literal.INSTANCE).fire("irrelevantPayload");
event.select(String.class, new DummyQualifier.Literal("foo")).fire("irrelevantPayload");