[generator] Use Avaje Prisms UType for Processing TypeMirrors (#484)

Author: SentryMan

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

@@ -62,7 +62,7 @@ private void validateFallback() {
     if (fallback == null) {
       return;
     }
-    var returnType = Util.trimAnnotations(fallback.getReturnType().toString());
+    var returnType = ProcessorUtils.trimAnnotations(fallback.getReturnType().toString());
     if (!returnType.contains(Util.shortName(rawReturn))) {
       APContext.logError(fallback, "An AOP fallback method must have the same return type as the target method");
     }

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

@@ -28,7 +28,7 @@ final class AssistBeanReader {
   AssistBeanReader(TypeElement beanType) {
     this.beanType = beanType;
     this.type = beanType.getQualifiedName().toString();
-    this.typeReader = new TypeReader(GenericType.parse(type), beanType, importTypes, false);
+    this.typeReader = new TypeReader(UType.parse(beanType.asType()), beanType, importTypes, false);
 
     typeReader.process();
     qualifierName = typeReader.name();
@@ -144,7 +144,7 @@ private String beanPackageName() {
     if (beanType.getNestingKind().isNested()) {
       return Util.nestedPackageOf(beanQualifiedName());
     } else {
-      return Util.packageOf(beanQualifiedName());
+      return ProcessorUtils.packageOf(beanQualifiedName());
     }
   }
 

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

@@ -40,7 +40,7 @@ final class BeanReader {
   private boolean writtenToFile;
   private boolean suppressBuilderImport;
   private boolean suppressGeneratedImport;
-  private Set<GenericType> allGenericTypes;
+  private Set<UType> allUTypes;
   private final boolean delayed;
 
   BeanReader(TypeElement beanType, boolean factory, boolean importedComponent) {
@@ -50,7 +50,7 @@ final class BeanReader {
     this.prototype = PrototypePrism.isPresent(beanType);
     this.primary = PrimaryPrism.isPresent(beanType);
     this.secondary = !primary && SecondaryPrism.isPresent(beanType);
-    this.typeReader = new TypeReader(GenericType.parse(type), beanType, importTypes, factory);
+    this.typeReader = new TypeReader(UType.parse(beanType.asType()), beanType, importTypes, factory);
 
     typeReader.process();
 
@@ -176,24 +176,24 @@ String providesAspect() {
     return typeReader.providesAspect();
   }
 
-  Set<GenericType> allGenericTypes() {
-    if (allGenericTypes != null) {
-      return allGenericTypes;
+  Set<UType> allGenericTypes() {
+    if (allUTypes != null) {
+      return allUTypes;
     }
-    allGenericTypes = new LinkedHashSet<>(typeReader.genericTypes());
+    allUTypes = new LinkedHashSet<>(typeReader.genericTypes());
     for (FieldReader field : injectFields) {
-      field.addDependsOnGeneric(allGenericTypes);
+      field.addDependsOnGeneric(allUTypes);
     }
     for (MethodReader method : injectMethods) {
-      method.addDependsOnGeneric(allGenericTypes);
+      method.addDependsOnGeneric(allUTypes);
     }
     if (constructor != null) {
-      constructor.addDependsOnGeneric(allGenericTypes);
+      constructor.addDependsOnGeneric(allUTypes);
     }
     for (MethodReader factoryMethod : factoryMethods()) {
-      factoryMethod.addDependsOnGeneric(allGenericTypes);
+      factoryMethod.addDependsOnGeneric(allUTypes);
     }
-    return allGenericTypes;
+    return allUTypes;
   }
 
   /**
@@ -311,11 +311,11 @@ private Set<String> importTypes() {
     aspects.extraImports(importTypes);
 
     for (MethodReader factoryMethod : factoryMethods) {
-      Set<GenericType> genericTypes = factoryMethod.genericTypes();
-      if (!genericTypes.isEmpty()) {
+      Set<UType> utypes = factoryMethod.genericTypes();
+      if (!utypes.isEmpty()) {
         importTypes.add(Constants.TYPE);
         importTypes.add(Constants.GENERICTYPE);
-        genericTypes.forEach(t->t.addImports(importTypes));
+        utypes.forEach(t -> importTypes.addAll(t.importTypes()));
       }
     }
     checkImports();
@@ -465,7 +465,7 @@ private String beanPackageName() {
     if (beanType.getNestingKind().isNested()) {
       return Util.nestedPackageOf(beanQualifiedName());
     } else {
-      return Util.packageOf(beanQualifiedName());
+      return ProcessorUtils.packageOf(beanQualifiedName());
     }
   }
 

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

@@ -7,23 +7,25 @@ final class Dependency {
   private final boolean conditionalDependency;
 
   Dependency(String name) {
+    String nameStr;
     if (name.startsWith("soft:")) {
       this.softDependency = true;
       this.conditionalDependency = false;
-      this.name = Util.trimAnnotations(name.substring(5));
+      nameStr = ProcessorUtils.trimAnnotations(name.substring(5));
     } else if (name.startsWith("con:")) {
       this.softDependency = true;
       this.conditionalDependency = true;
-      this.name = Util.trimAnnotations(name.substring(4));
+      nameStr = ProcessorUtils.trimAnnotations(name.substring(4));
     } else {
       this.softDependency = false;
       this.conditionalDependency = false;
-      this.name = Util.trimAnnotations(name);
+      nameStr = ProcessorUtils.trimAnnotations(name);
     }
+    this.name = nameStr.replace(",", ", ");
   }
 
   Dependency(String name, boolean softDependency) {
-    this.name = Util.trimAnnotations(name);
+    this.name = ProcessorUtils.trimAnnotations(name).replace(",", ", ");
     this.softDependency = softDependency;
     this.conditionalDependency = false;
   }

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

@@ -11,7 +11,7 @@ final class FieldReader {
   private final UtilType utype;
   private final boolean nullable;
   private final String fieldType;
-  private final GenericType type;
+  private final UType type;
   private boolean requestParam;
   private String requestParamName;
   private final boolean isBeanMap;
@@ -24,18 +24,18 @@ final class FieldReader {
     this.utype = Util.determineType(element.asType());
     this.isBeanMap = QualifiedMapPrism.isPresent(element);
     this.fieldType = Util.unwrapProvider(utype.rawType(isBeanMap));
-    this.type = GenericType.parse(utype.rawType(isBeanMap));
+    this.type = utype.toUType();
     this.assisted = AssistedPrism.isPresent(element);
     if (nullable || element.asType().toString().startsWith("java.util.Optional<")) {
       ProcessingContext.addOptionalType(fieldType);
     }
   }
 
   boolean isGenericParam() {
-    return type.isGenericType() && !type.isProviderType();
+    return type.isGeneric() && !Util.isProvider(type.mainType());
   }
 
-  void addDependsOnGeneric(Set<GenericType> set) {
+  void addDependsOnGeneric(Set<UType> set) {
     if (isGenericParam()) {
       set.add(type);
     }
@@ -46,16 +46,16 @@ String fieldName() {
   }
 
   void addImports(ImportTypeMap importTypes) {
-    type.addImports(importTypes);
+    importTypes.addAll(type.importTypes());
   }
 
   String builderGetDependency(String builder) {
     final var sb = new StringBuilder();
     sb.append(builder).append(".").append(utype.getMethod(nullable, isBeanMap));
     if (isGenericParam()) {
-      sb.append("TYPE_").append(type.shortName().replace(".", "_"));
+      sb.append("TYPE_").append(Util.shortName(type).replace(".", "_"));
     } else {
-      var trimmed = Util.trimAnnotations(fieldType);
+      var trimmed = ProcessorUtils.trimAnnotations(fieldType);
       sb.append(Util.shortName(trimmed)).append(".class");
     }
     if (name != null) {
@@ -65,8 +65,8 @@ String builderGetDependency(String builder) {
     return sb.toString();
   }
 
-  void removeFromProvides(List<String> provides) {
-    provides.remove(type.toString());
+  void removeFromProvides(List<UType> provides) {
+    provides.remove(type);
   }
 
   /**
@@ -87,7 +87,7 @@ void writeRequestDependency(Append writer) {
       // just add as field dependency
       requestParamName = writer.nextName(fieldName().toLowerCase());
       writer.append("  @Inject").eol().append("  ");
-      type.writeShort(writer);
+      writer.append(type.shortType());
       writer.append(" %s;", requestParamName).eol().eol();
     }
   }