#157 - Support @factory with method return types including generic wildard <?> and generic types

Author: rbygrave

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

@@ -9,6 +9,17 @@
  */
 class GenericType {
 
+  /**
+   * Trim off generic wildcard from the raw type if present.
+   */
+  static String trimWildcard(String rawType) {
+    if (rawType.endsWith("<?>")) {
+      return rawType.substring(0, rawType.length() - 3);
+    } else {
+      return rawType;
+    }
+  }
+
   private final String raw;
   private String mainType;
 
@@ -39,6 +50,10 @@ static boolean isGeneric(String raw) {
    * Parse and return as GenericType.
    */
   static GenericType parse(String raw) {
+    raw = trimWildcard(raw);
+    if (raw.indexOf('<') == -1) {
+      return new GenericType(raw);
+    }
     return new GenericTypeParser(raw).parse();
   }
 
@@ -87,8 +102,8 @@ void addImports(Set<String> importTypes) {
     }
   }
 
-  private boolean includeInImports(String type) {
-    return !type.startsWith("java.lang.") && type.contains(".");
+  private static boolean includeInImports(String type) {
+    return type != null && !type.startsWith("java.lang.") && type.contains(".");
   }
 
   /**
@@ -126,10 +141,15 @@ void shortName(StringBuilder sb) {
   }
 
   private String trimExtends() {
-    if (mainType.startsWith("? extends ")) {
-      return mainType.substring(10);
+    String type = topType();
+    if (type != null &&  type.startsWith("? extends ")) {
+      return type.substring(10);
     }
-    return mainType;
+    return type;
+  }
+
+  String topType() {
+    return (mainType != null) ? mainType : raw;
   }
 
   /**

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

@@ -17,6 +17,7 @@ class MethodReader {
   private final String factoryType;
   private final String methodName;
   private final String returnTypeRaw;
+  private final GenericType genericType;
   private final String shortName;
   private final boolean isVoid;
   private final List<MethodParam> params = new ArrayList<>();
@@ -40,19 +41,21 @@ class MethodReader {
     String raw = returnMirror.toString();
     if (Util.isOptional(raw)) {
       optionalType = true;
-      returnTypeRaw = Util.extractOptionalType(raw);
+      returnTypeRaw = GenericType.trimWildcard(Util.extractOptionalType(raw));
     } else {
       optionalType = false;
-      returnTypeRaw = raw;
+      returnTypeRaw = GenericType.trimWildcard(raw);
     }
-    this.shortName = Util.shortName(returnTypeRaw);
+    this.genericType = GenericType.parse(returnTypeRaw);
+    String topType = genericType.topType();
+    this.shortName = Util.shortName(topType);
     this.factoryType = beanType.getQualifiedName().toString();
     this.factoryShortName = Util.shortName(factoryType);
-    this.isVoid = Util.isVoid(returnTypeRaw);
+    this.isVoid = Util.isVoid(topType);
     String initMethod = (bean == null) ? null : bean.initMethod();
     String destroyMethod = (bean == null) ? null : bean.destroyMethod();
     this.name = (named == null) ? null : named.value().toLowerCase();
-    TypeElement returnElement = context.element(returnTypeRaw);
+    TypeElement returnElement = context.element(topType);
     if (returnElement == null) {
       this.typeReader = null;
       this.initMethod = initMethod;
@@ -164,7 +167,7 @@ void addImports(Set<String> importTypes) {
       param.addImports(importTypes);
     }
     if (isFactory) {
-      importTypes.add(returnTypeRaw);
+      genericType.addImports(importTypes);
     }
     if (optionalType) {
       importTypes.add(Constants.OPTIONAL);

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

@@ -27,6 +27,7 @@ static String classOfMethod(String method) {
   }
 
   static String shortMethod(String method) {
+    method = trimGenerics(method);
     int p = method.lastIndexOf('.');
     if (p > -1) {
       p = method.lastIndexOf('.', p - 1);
@@ -37,6 +38,14 @@ static String shortMethod(String method) {
     return method;
   }
 
+  static String trimGenerics(String type) {
+    int i = type.indexOf('<');
+    if (i == -1) {
+      return type;
+    }
+    return type.substring(0, i);
+  }
+
   static String packageOf(String cls) {
     int pos = cls.lastIndexOf('.');
     return (pos == -1) ? "" : cls.substring(0, pos);

inject-generator/src/test/java/io/avaje/inject/generator/GenericTypeTest.java

@@ -3,30 +3,29 @@
 import org.junit.jupiter.api.Test;
 
 import java.io.StringWriter;
+import java.util.HashSet;
+import java.util.Set;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 class GenericTypeTest {
 
   @Test
   void isGeneric() {
-
     assertFalse(GenericType.isGeneric("java.lang.List"));
     assertTrue(GenericType.isGeneric("java.lang.List<Foo>"));
+    assertTrue(GenericType.isGeneric("java.lang.List<?>"));
   }
 
   @Test
   void maybe() {
-
     assertThat(GenericType.maybe("java.lang.List<Foo>").getMainType()).isEqualTo("java.lang.List");
     assertThat(GenericType.maybe("java.lang.List")).isNull();
   }
 
   @Test
   void parse() {
-
     GenericType type = new GenericTypeParser("my.exa.Repo<T,K>").parse();
 
     assertThat(type.getMainType()).isEqualTo("my.exa.Repo");
@@ -36,8 +35,50 @@ void parse() {
   }
 
   @Test
-  void parse_withParams() {
+  void parse_basic() {
+    GenericType type = GenericType.parse("my.exa.Repo");
+    assertThat(type.shortName()).isEqualTo("Repo");
+    assertThat(type.topType()).isEqualTo("my.exa.Repo");
+    assertThat(type.getMainType()).isNull();
+    assertThat(type.getParams()).isEmpty();
+
+    Set<String> importSet = new HashSet<>();
+    type.addImports(importSet);
+    assertThat(importSet).hasSize(1);
+    assertThat(importSet).containsOnly("my.exa.Repo");
+  }
+
+  @Test
+  void parse_genericWildcard() {
+    GenericType type = GenericType.parse("my.exa.Repo<?>");
+    assertThat(type.shortName()).isEqualTo("Repo");
+    assertThat(type.topType()).isEqualTo("my.exa.Repo");
+    assertThat(type.getMainType()).isNull();
+    assertThat(type.getParams()).isEmpty();
+
+    Set<String> importSet = new HashSet<>();
+    type.addImports(importSet);
+    assertThat(importSet).hasSize(1);
+    assertThat(importSet).containsOnly("my.exa.Repo");
+  }
+
+  @Test
+  void parse_withParam() {
+    GenericType type = GenericType.parse("my.exa.Repo<my.Other>");
+    assertThat(type.shortName()).isEqualTo("RepoOther");
+    assertThat(type.topType()).isEqualTo("my.exa.Repo");
+    assertThat(type.getMainType()).isEqualTo("my.exa.Repo");
+    assertThat(type.getParams()).hasSize(1);
+    assertThat(type.getParams().get(0).getMainType()).isEqualTo("my.Other");
 
+    Set<String> importSet = new HashSet<>();
+    type.addImports(importSet);
+    assertThat(importSet).hasSize(2);
+    assertThat(importSet).contains("my.exa.Repo", "my.Other");
+  }
+
+  @Test
+  void parse_withParams() {
     GenericType type = GenericType.parse("my.exa.Repo<my.d.Haz,java.lang.Long>");
 
     assertThat(type.getMainType()).isEqualTo("my.exa.Repo");
@@ -48,7 +89,6 @@ void parse_withParams() {
 
   @Test
   void parse_withExtendsParams() {
-
     GenericType type = new GenericTypeParser("my.exa.Repo<? extends my.d.Haz,java.lang.Long>").parse();
 
     assertThat(type.getMainType()).isEqualTo("my.exa.Repo");
@@ -59,7 +99,6 @@ void parse_withExtendsParams() {
 
   @Test
   void parse_withNestedParams() {
-
     GenericType type = new GenericTypeParser("my.exa.Repo<my.a.Prov<my.b.Haz>,my.a.Key<java.util.UUID>>").parse();
 
     assertThat(type.getMainType()).isEqualTo("my.exa.Repo");
@@ -96,8 +135,14 @@ void removeParameter() {
   }
 
   @Test
-  void write() {
+  void trimWildcard() {
+    assertEquals("my.exa.Repo", GenericType.trimWildcard("my.exa.Repo<?>"));
+    assertEquals("my.exa.Repo", GenericType.trimWildcard("my.exa.Repo"));
+    assertEquals("my.exa.Repo<my.Other>", GenericType.trimWildcard("my.exa.Repo<my.Other>"));
+  }
 
+  @Test
+  void write() {
     GenericType type = new GenericTypeParser("my.exa.Repo<my.a.Prov<my.b.Haz>,my.a.Key<java.util.UUID>>").parse();
 
     StringWriter stringWriter = new StringWriter();

inject-generator/src/test/java/io/avaje/inject/generator/UtilTest.java

@@ -66,4 +66,15 @@ void initLower() {
     assertThat(Util.initLower("Time")).isEqualTo("time");
     assertThat(Util.initLower("TiMe")).isEqualTo("tiMe");
   }
+
+  @Test
+  void trimGenerics() {
+    assertThat(Util.trimGenerics("foo.bar.ProcessMe<java.lang.String>")).isEqualTo("foo.bar.ProcessMe");
+    assertThat(Util.trimGenerics("foo.bar.ProcessMe")).isEqualTo("foo.bar.ProcessMe");
+  }
+
+  @Test
+  void trimMethod_when_genericType() {
+    assertThat(Util.trimMethod("foo.bar.ProcessMe<java.lang.String>")).isEqualTo("bar_ProcessMe");
+  }
 }

inject-test/src/test/java/org/example/autonamed/MyAutoNameFactory.java

@@ -3,10 +3,29 @@
 import io.avaje.inject.Bean;
 import io.avaje.inject.Factory;
 import jakarta.inject.Named;
+import org.example.iface.Some;
 
 @Factory
 public class MyAutoNameFactory {
 
+  @Named("wild")
+  @Bean
+  MyGeneric<?> genericWildcard() {
+    return new DMyGeneric<>();
+  }
+
+  @Named("genericString")
+  @Bean
+  MyGeneric<String> genericString() {
+    return new DMyGeneric<>();
+  }
+
+  @Named("genericOther")
+  @Bean
+  MyGeneric<Some> genericWithSomeType() {
+    return new DMyGeneric<>();
+  }
+
   @Bean
   AutoIface one() {
     return new DAutoIface("one");
@@ -47,4 +66,12 @@ public String who() {
       return name;
     }
   }
+
+  static class DMyGeneric<T> implements MyGeneric<T> {
+
+    @Override
+    public T obtain() {
+      return null;
+    }
+  }
 }

inject-test/src/test/java/org/example/autonamed/MyAutoNameTest.java

@@ -38,6 +38,15 @@ void test() {
 
       final MyAutoName2 myAutoName2 = beanScope.get(MyAutoName2.class);
       assertThat(myAutoName2.who()).isEqualTo("one");
+
+      final MyGeneric<?> genericWild = beanScope.get(MyGeneric.class, "wild");
+      final MyGeneric<?> generic2 = beanScope.get(MyGeneric.class, "genericString");
+      final MyGeneric<?> generic3 = beanScope.get(MyGeneric.class, "genericOther");
+      assertThat(genericWild).isNotNull();
+      assertThat(generic2).isNotNull();
+      assertThat(generic3).isNotNull();
+      assertThat(genericWild).isNotSameAs(generic2);
+      assertThat(generic2).isNotSameAs(generic3);
     }
   }
 }

inject-test/src/test/java/org/example/autonamed/MyGeneric.java

@@ -0,0 +1,6 @@
+package org.example.autonamed;
+
+public interface MyGeneric<T> {
+
+  T obtain();
+}