Fix injecting generic types extending generic types

blackbox-test-inject/src/main/java/org/example/myapp/generic/Aldrich.java

@@ -0,0 +1,6 @@
+package org.example.myapp.generic;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public interface Aldrich<T, T2> extends BiConsumer<T, T2>, Consumer<BiConsumer<T, T2>> {}

blackbox-test-inject/src/main/java/org/example/myapp/generic/MyA.java

@@ -0,0 +1,4 @@
+package org.example.myapp.generic;
+
+public interface MyA {
+}

blackbox-test-inject/src/main/java/org/example/myapp/generic/MyB.java

@@ -0,0 +1,4 @@
+package org.example.myapp.generic;
+
+public interface MyB {
+}

blackbox-test-inject/src/main/java/org/example/myapp/generic/MyConsumer.java

@@ -0,0 +1,9 @@
+package org.example.myapp.generic;
+
+import java.util.function.BiConsumer;
+
+public class MyConsumer implements BiConsumer<MyA, MyB> {
+
+  @Override
+  public void accept(MyA t, MyB u) {}
+}

blackbox-test-inject/src/main/java/org/example/myapp/generic/MyConsumerFactory.java

@@ -0,0 +1,37 @@
+package org.example.myapp.generic;
+
+import io.avaje.inject.Bean;
+import io.avaje.inject.Factory;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+@Factory
+class MyConsumerFactory {
+
+  @Bean
+  MyConsumer createTest() {
+    return new MyConsumer();
+  }
+
+  @Bean
+  Map<String, MyConsumer> genericMap(BiConsumer<MyA, MyB> consumer) {
+    return new HashMap<>();
+  }
+
+  @Bean
+  Aldrich<String, String> bean() {
+    return new Aldrich<>() {
+      @Override
+      public void accept(String s, String s2) {
+
+      }
+
+      @Override
+      public void accept(BiConsumer<String, String> stringStringBiConsumer) {
+
+      }
+    };
+  }
+}

blackbox-test-inject/src/main/java/org/example/myapp/generic/MyUseGenericDependencies.java

@@ -0,0 +1,34 @@
+package org.example.myapp.generic;
+
+import jakarta.inject.Singleton;
+
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+@Singleton
+class MyUseGenericDependencies {
+
+  private final Aldrich<String, String> aldrich;
+  private final Map<String, MyConsumer> genericMap;
+  private final BiConsumer<MyA, MyB> biConsumer;
+
+  MyUseGenericDependencies(Aldrich<String, String> aldrich,
+                           Map<String, MyConsumer> genericMap,
+                           BiConsumer<MyA, MyB> biConsumer) {
+    this.aldrich = aldrich;
+    this.genericMap = genericMap;
+    this.biConsumer = biConsumer;
+  }
+
+  Aldrich<String, String> getAldrich() {
+    return aldrich;
+  }
+
+  Map<String, MyConsumer> getGenericMap() {
+    return genericMap;
+  }
+
+  BiConsumer<MyA, MyB> getBiConsumer() {
+    return biConsumer;
+  }
+}

blackbox-test-inject/src/test/java/org/example/myapp/generic/GenericFactoryTest.java

@@ -12,10 +12,14 @@ class GenericFactoryTest {
 
   @Inject Generic<Integer> intymcintface;
   @Inject Generic<String> stringy;
+  @Inject MyUseGenericDependencies others;
 
   @Test
   void test() {
     assertThat(intymcintface).isNotNull();
     assertThat(stringy).isNotNull();
+    assertThat(others.getAldrich()).isNotNull();
+    assertThat(others.getGenericMap()).isNotNull();
+    assertThat(others.getBiConsumer()).isNotNull();
   }
 }

inject-generator/src/main/java/io/avaje/inject/generator/TypeAppender.java

@@ -3,6 +3,7 @@
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import javax.lang.model.type.TypeKind;
 
@@ -21,22 +22,31 @@ final class TypeAppender {
 
   void add(UType utype) {
     var type = Util.unwrapProvider(utype);
-    var components = type.componentTypes();
-    if (isAddGenericType(type, components)) {
+    if (isAddGenericType(type)) {
       addUType(type);
     } else {
       addSimpleType(type.mainType());
     }
   }
 
-  private static boolean isAddGenericType(UType type, List<UType> components) {
+  private static boolean isAddGenericType(UType type) {
+    var components = type.componentTypes();
     return type.isGeneric()
       && type.kind() != TypeKind.TYPEVAR
       && (components.size() != 1 || components.get(0).kind() != TypeKind.WILDCARD)
       && components.stream()
+      .flatMap(TypeAppender::allComponentTypes)
       .noneMatch(u -> u.kind() == TypeKind.TYPEVAR || u.kind() == TypeKind.WILDCARD);
   }
 
+  private static Stream<UType> allComponentTypes(UType u) {
+    final var componentTypes = u.componentTypes();
+    return componentTypes.isEmpty()
+      ? Stream.of(u)
+      : Stream.concat(
+        Stream.of(u), componentTypes.stream().flatMap(TypeAppender::allComponentTypes));
+  }
+
   void add(List<UType> sourceTypes) {
     sourceTypes.forEach(this::add);
   }

inject-generator/src/test/java/io/avaje/inject/generator/models/valid/provider/BProv.java

@@ -0,0 +1,14 @@
+package io.avaje.inject.generator.models.valid.provider;
+
+public class BProv<T> {
+
+  final T value;
+
+  public BProv(T value) {
+    this.value = value;
+  }
+
+  public T get() {
+    return value;
+  }
+}

inject-generator/src/test/java/io/avaje/inject/generator/models/valid/provider/BProvProvider.java

@@ -0,0 +1,17 @@
+package io.avaje.inject.generator.models.valid.provider;
+
+import io.avaje.inject.Component;
+import jakarta.inject.Provider;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Component
+public class BProvProvider implements Provider<BProv<String>> {
+
+  AtomicInteger counter = new AtomicInteger();
+
+  @Override
+  public BProv<String> get() {
+    return new BProv<>("Hello BProv" + counter.incrementAndGet());
+  }
+}

inject-test/src/test/java/org/example/coffee/provider/BProvProviderTest.java

@@ -17,6 +17,11 @@ void providerOfGenericType() {
       BProv<String> bProv2 = beanScope.get(BProvProvider$DI.TYPE_BProvString);
       assertThat(bProv).isNotSameAs(bProv2);
       assertThat(bProv2.get()).isEqualTo("Hello BProv2");
+
+      BProvUser bProvUser = beanScope.get(BProvUser.class);
+      BProv<String> bProv3 = bProvUser.getProvider().get();
+      assertThat(bProv3.get()).isEqualTo("Hello BProv3");
+      assertThat(bProv).isNotSameAs(bProv3);
     }
   }
 

inject-test/src/test/java/org/example/coffee/provider/BProvUser.java

@@ -0,0 +1,18 @@
+package org.example.coffee.provider;
+
+import io.avaje.inject.Component;
+import jakarta.inject.Provider;
+
+@Component
+class BProvUser {
+
+  private final Provider<BProv<String>> provider;
+
+  BProvUser(Provider<BProv<String>> provider){
+    this.provider = provider;
+  }
+
+  Provider<BProv<String>> getProvider() {
+    return provider;
+  }
+}