Micronaut mixes up a qualified bean from unqualified one when @Replace is used

[RonBarkan]

Expected Behavior

When a factory provides a qualified bean and an unqualified bean, Micronaut can't resolve the qualified one.

Example:

@Factory
@Prototype
public class MyFactory {

  @Named("blah")
  @Prototype
  CountDownLatch blah() {
    return new CountDownLatch(1);
  }

  @Singleton
  @Replaces(CountDownLatch.class)
  CountDownLatch foo() {
    return new CountDownLatch(1);
  }
}

@Prototype
public class MyClass {

  @Inject
  public MyClass(@Named("blah") CountDownLatch latch) { }
}

Note there's a Micronaut provided @Factory, which is why @Replaces is used:

@Factory
public class MicronautFactory {
  @Bean
  CountDownLatch foo() {
    return new CountDownLatch(7);  //  7 is really bad for my app :-)
  }
}

This should work but does not.

Actual Behaviour

Even though @Replaces is not qualified, it eliminates the qualified bean, so this code will not run and complain:
No bean of type [java.util.concurrent.CountDownLatch] exists for the given qualifier: @Named('blah')

Same thing with a qualifier annotation.

Steps To Reproduce

See above code snippet.

Environment Information

JDK 21 / Linux

Example Application

No response

Version

3.10.1

[hrothwell]

When you specify the replacement bean using @Singleton I would assume it would then remove all non-singletons of said type and thus replace your qualified bean.

Also in this example, what benefit is there to using @Replaces? If you need a specific instance of this type that you can access without using qualifiers (ie a default) you might be best suited using @Primary in this example, assuming that is the intention of the replacing going on

[hrothwell]

not sure if what I described above is your use case, but if so this along the lines of what I was describing

import io.micronaut.context.annotation.*;
import jakarta.inject.Inject;
import jakarta.inject.Named;

@Factory
@Prototype
class MyFactory {

    @Named("blah")
    @Prototype
    String blah() {
        return "blah";
    }

    @Bean
    @Primary
    String primary() {
        return "primary";
    }
}

@Prototype
class MyClass {

    String myString;

    @Inject
    public MyClass(@Named("blah") String s) {
        myString = s;
    }

    public String getMyString(){
        return myString;
    }
}

@Prototype
class MyClassTwo{
    String myString;
    @Inject
    public MyClassTwo(String s){
        myString = s;
    }

    public String getMyString(){
        return myString;
    }
}

import io.micronaut.inject.qualifiers.Qualifiers
import io.micronaut.runtime.EmbeddedApplication
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest
class ExampleSpec extends Specification{
    @Inject
    EmbeddedApplication<?> application

    def 'named bean can be found'(){
        when:
        def bean = application.getApplicationContext().getBean(String.class, Qualifiers.byName('blah'))

        then:
        bean == 'blah'
    }

    def 'when no qualifier return primary'(){
        when:
        def bean = application.getApplicationContext().getBean(String.class)

        then:
        bean == 'primary'
    }

    def 'classes that inject can use the named or the primary'(){
        when:
        def myClass = application.getApplicationContext().getBean(MyClass.class)
        def myClassTwo = application.getApplicationContext().getBean(MyClassTwo.class)

        then:
        myClass.getMyString() == 'blah'
        myClassTwo.getMyString() == 'primary'
    }
}

[RonBarkan]

Also in this example, what benefit is there to using @Replaces?

The complete example has a Micronaut provided default instance, which needs to be replaced. Think that there's another @Factory somewhere that provides the same unqualified type, which needs replacement. However, it is not necessary in order to show the defect. I updated the first post anyway to note this.

The singleton question is only tangentially related, and should definitely not affect the qualified bean, because the qualified and unqualified beans should be unrelated and separate.

Indeed, @Primary does work, but I don't see any reason why @Replaces does not.
In particular, @Replaces has named and qualifier modifiers, which allows replacing @Named("blah") (in theory, I did not check), but they seem to be useless to not erase the qualified bean.

[RonBarkan]

In any case, the current behavior does not make sense.
Either:

1. The @Replaces actually replaces all instances, including differently qualified. This will be a questionable design, but maybe someone can justify it.
2. It impacts only the very specific type + name/qualifier (if any) and not any other of same type but different qualifier. This seems the most logical and easy to reason about.

Instead, the code erases the differently qualified beans from existence (!) and replaces the one that requires replacement.