Class annotated with @Implementation cannot have constructor with argument of parametrised type.

[AlexWih]

If my implementation has input argument of parametrised type T like this:

@Implementation(forType = Foo.class)
public class FooImpl<T extends Number> implements Foo {

    public FooImpl(T dependency) {

    }
}

then compilation of generated class MagnetFooImplFactory gets failed:

public final class MagnetFooImplFactory implements Factory<Foo> {
  @Override
  public Foo create(DependencyScope dependencyScope) {
    T dependency = dependencyScope.require(T.class);
    return new FooImpl(dependency);
  }
}

[sergejsha]

Before getting a dependency from the scope someone needs to put this dependency into the scope. How would you write the code for putting it in this particular case?

[AlexWih]

As T is a subtype of Number then the DependencyScope should receive some subtype of Number, i.e.:
dependencyScope.register(Long.class, Long.MAX_VALUE);

[sergejsha]

And in case when I put

dependencyScope.register(Long.class, Long.MAX_VALUE);
dependencyScope.register(Byte.class, Byte.MIN_VALUE);

which value should be provided to constructor of FooImpl?

[AlexWih]

I believe it is a design decision.
I would expect runtime error as both dependencies match.
Or alternatively the qualifiers could be utilised as Dagger does.

[sergejsha]

I was thinking about adding qualifiers later on, but they won't help here. It will still be possible to add both Float and Byte types with the same qualifier, which is fully valid construct, and this will produce ambiguity when the type is requested though a generic type. I believe even Dagger will fail to inject a generic type due to mentioned type ambiguity.

I'm going to disallow generics in implementation constructors for now. However compiler will fail with a meaningful message.

[sergejsha]

Moreover, it is always possible to resolve this ambiguity manually in the constructor. Just add DependencyScope as a constructor parameter and then request from the scope whatever needed.