Use strings for provides/requires

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

@@ -6,10 +6,10 @@
 
 import java.io.FileWriter;
 import java.io.IOException;
-import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -84,24 +84,21 @@ static void registerModuleProvidedTypes(Set<String> providedTypes) {
     for (final var module : modules) {
       final var name = module.getClass().getTypeName();
       final var provides = new TreeSet<String>();
-      for (final var provide : module.provides()) {
-        provides.add(provide.getTypeName());
-      }
-      for (final var provide : module.autoProvides()) {
-        provides.add(provide.getTypeName());
-      }
+      Collections.addAll(provides, module.providesBeans());
       for (final var provide : module.autoProvidesAspects()) {
         final var aspectType = Util.wrapAspect(provide.getTypeName());
         provides.add(aspectType);
       }
       registerExternalMetaData(name);
       readMetaDataProvides(provides);
       providedTypes.addAll(provides);
-      final var requires = Arrays.stream(module.requires()).map(Type::getTypeName).collect(toList());
-
-      Arrays.stream(module.autoRequires()).map(Type::getTypeName).forEach(requires::add);
-      Arrays.stream(module.requiresPackages()).map(Type::getTypeName).forEach(requires::add);
-      Arrays.stream(module.autoRequiresAspects()).map(Type::getTypeName).map(Util::wrapAspect).forEach(requires::add);
+      final List<String> requires = new ArrayList<>();
+      Collections.addAll(requires, module.requiresBeans());
+      Collections.addAll(requires, module.requiresPackagesFromType());
+      Arrays.stream(module.autoRequiresAspects())
+          .map(Class::getTypeName)
+          .map(Util::wrapAspect)
+          .forEach(requires::add);
 
       ProcessingContext.addModule(new ModuleData(name, List.copyOf(provides), requires));
     }

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

@@ -25,7 +25,6 @@ final class MetaDataOrdering {
   private final List<DependencyLink> circularDependencies = new ArrayList<>();
   private final Set<String> missingDependencyTypes = new LinkedHashSet<>();
   private final Set<String> autoRequires = new TreeSet<>();
-  private final Set<String> autoRequiresAspects = new TreeSet<>();
 
   MetaDataOrdering(Collection<MetaData> values, ScopeInfo scopeInfo) {
     this.scopeInfo = scopeInfo;
@@ -224,11 +223,7 @@ private boolean dependencySatisfied(Dependency dependency, boolean includeExtern
 
   private boolean isExternal(String dependencyName, boolean includeExternal, MetaData queuedMeta) {
     if (includeExternal && externallyProvided(dependencyName)) {
-      if (Util.isAspectProvider(dependencyName)) {
-        autoRequiresAspects.add(Util.extractAspectType(dependencyName));
-      } else {
-        autoRequires.add(dependencyName);
-      }
+      autoRequires.add(dependencyName);
       queuedMeta.markWithExternalDependency(dependencyName);
       return true;
     }
@@ -239,10 +234,6 @@ Set<String> autoRequires() {
     return autoRequires;
   }
 
-  Set<String> autoRequiresAspects() {
-    return autoRequiresAspects;
-  }
-
   List<MetaData> ordered() {
     return orderedList;
   }

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

@@ -130,6 +130,8 @@ private void read(Element element) {
     ignoreSingleton = injectModule.ignoreSingleton();
     injectModule.requires().stream().map(Object::toString).forEach(requires::add);
     injectModule.provides().stream().map(Object::toString).forEach(provides::add);
+    requires.addAll(injectModule.requiresString());
+    provides.addAll(injectModule.providesString());
     injectModule.requiresPackages().stream()
         .map(Object::toString)
         .forEach(
@@ -391,12 +393,42 @@ void buildAtInjectModule(Append writer) {
     writer.append(Constants.AT_GENERATED).eol();
     writer.append("@InjectModule(");
     boolean leadingComma = false;
-    if (!provides.isEmpty()) {
+    List<String> regularProvides = new ArrayList<>();
+    List<String> genericProvides = new ArrayList<>();
+
+    for (var type : provides) {
+      if (type.contains("<")) {
+        genericProvides.add(type);
+      } else {
+        regularProvides.add(type);
+      }
+    }
+
+    if (!regularProvides.isEmpty()) {
       attributeClasses(false, writer, "provides", provides);
       leadingComma = true;
     }
-    if (!requires.isEmpty()) {
-      attributeClasses(leadingComma, writer, "requires", requires);
+    if (!genericProvides.isEmpty()) {
+      attributeString(false, writer, "providesString", provides);
+      leadingComma = true;
+    }
+
+    List<String> regularRequires = new ArrayList<>();
+    List<String> genericRequires = new ArrayList<>();
+
+    for (var type : requires) {
+      if (type.contains("<")) {
+        genericRequires.add(type);
+      } else {
+        regularRequires.add(type);
+      }
+    }
+    if (!regularRequires.isEmpty()) {
+      attributeClasses(leadingComma, writer, "requires", regularRequires);
+      leadingComma = true;
+    }
+    if (!genericRequires.isEmpty()) {
+      attributeString(leadingComma, writer, "requiresString", requires);
       leadingComma = true;
     }
     if (!requiresPackages.isEmpty()) {
@@ -412,7 +444,23 @@ void buildAtInjectModule(Append writer) {
     writer.append(")").eol();
   }
 
-  private void attributeClasses(boolean leadingComma, Append writer, String prefix, Set<String> classNames) {
+  private void attributeString(
+      boolean leadingComma, Append writer, String prefix, Set<String> classNames) {
+    if (leadingComma) {
+      writer.append(", ");
+    }
+    writer.append("%s = {", prefix);
+    int c = 0;
+    for (final String value : classNames) {
+      if (c++ > 0) {
+        writer.append(",");
+      }
+      writer.append("\"%s\"", value);
+    }
+    writer.append("}");
+  }
+
+  private void attributeClasses(boolean leadingComma, Append writer, String prefix, Collection<String> classNames) {
     if (leadingComma) {
       writer.append(", ");
     }
@@ -427,67 +475,33 @@ private void attributeClasses(boolean leadingComma, Append writer, String prefix
     writer.append("}");
   }
 
-  void buildProvides(Append writer) {
+  void buildProvides(Append writer, Set<String> provides, Set<String> requires) {
     if (!provides.isEmpty()) {
-      buildProvidesMethod(writer, "provides", provides);
+      buildProvidesMethod(writer, "providesBeans", provides);
     }
     if (!requires.isEmpty()) {
-      buildProvidesMethod(writer, "requires", requires);
+      buildProvidesMethod(writer, "requiresBeans", requires);
     }
     if (!requiresPackages.isEmpty()) {
-      buildProvidesMethod(writer, "requiresPackages", requiresPackages);
+      buildProvidesMethod(writer, "requiresPackagesFromType", requiresPackages);
     }
   }
 
   private void buildProvidesMethod(Append writer, String fieldName, Set<String> types) {
     writer.append("  @Override").eol();
-    final var arrayType = fieldName.contains("Aspects") ? "Class<?>" : "Type";
-    writer.append("  public %s[] %s() {", arrayType, fieldName).eol();
-    writer.append("    return new %s[] {", arrayType).eol();
+    writer.append("  public String[] %s() {", fieldName).eol();
+    writer.append("    return new String[] {").eol();
     for (final String rawType : types) {
 
       if (rawType.contains(":")) {
         continue;
       }
-
-      if (rawType.contains("<")) {
-        writer.append("      new GenericType<%s>(){},", rawType).eol();
-      } else {
-        writer.append("      %s.class,", rawType).eol();
-      }
+      writer.append("      \"%s\",", rawType).eol();
     }
     writer.append("    };").eol();
     writer.append("  }").eol().eol();
   }
 
-  void buildAutoProvides(Append writer, Set<String> autoProvides) {
-    autoProvides.removeAll(provides);
-    if (!autoProvides.isEmpty()) {
-      buildProvidesMethod(writer, "autoProvides", autoProvides);
-    }
-  }
-
-  void buildAutoProvidesAspects(Append writer, Set<String> autoProvidesAspects) {
-    autoProvidesAspects.removeAll(provides);
-    if (!autoProvidesAspects.isEmpty()) {
-      buildProvidesMethod(writer, "autoProvidesAspects", autoProvidesAspects);
-    }
-  }
-
-  void buildAutoRequires(Append writer, Set<String> autoRequires) {
-    autoRequires.removeAll(requires);
-    if (!autoRequires.isEmpty()) {
-      buildProvidesMethod(writer, "autoRequires", autoRequires);
-    }
-  }
-
-  void buildAutoRequiresAspects(Append writer, Set<String> autoRequires) {
-    autoRequires.removeAll(requires);
-    if (!autoRequires.isEmpty()) {
-      buildProvidesMethod(writer, "autoRequiresAspects", autoRequires);
-    }
-  }
-
   void readModuleMetaData(TypeElement moduleType) {
     final InjectModulePrism module = InjectModulePrism.getInstanceOn(moduleType);
     final String name = module == null ? null : module.name();

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

@@ -1,13 +1,23 @@
 package io.avaje.inject.generator;
 
-import static io.avaje.inject.generator.APContext.*;
-import static io.avaje.inject.generator.ProcessingContext.*;
+import static io.avaje.inject.generator.APContext.logError;
+import static io.avaje.inject.generator.APContext.typeElement;
+import static io.avaje.inject.generator.ProcessingContext.allScopes;
+import static io.avaje.inject.generator.ProcessingContext.createMetaInfWriterFor;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.Collectors.toSet;
 
 import java.io.IOException;
 import java.io.Writer;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeSet;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
@@ -86,9 +96,9 @@ void write() throws IOException {
     } else {
       writeRequiredModules();
     }
+    writeBuildMethod();
     writeProvides();
     writeClassesMethod();
-    writeBuildMethod();
     writeBuildMethods();
     writeEndClass();
     writer.close();
@@ -178,45 +188,28 @@ private void writeServicesFile(ScopeInfo.Type scopeType) {
   }
 
   private void writeProvides() {
-    final Set<String> autoProvidesAspects = new TreeSet<>();
-    final Set<String> autoProvides = new TreeSet<>();
+    final Set<String> scopeProvides = new TreeSet<>(scopeInfo.provides());
 
     if (scopeType == ScopeInfo.Type.CUSTOM) {
-      autoProvides.add(scopeInfo.scopeAnnotationFQN());
-      autoProvides.add(shortName);
+      scopeProvides.add(scopeInfo.scopeAnnotationFQN());
+      scopeProvides.add(shortName);
     }
-
     for (MetaData metaData : ordering.ordered()) {
       final String aspect = metaData.providesAspect();
       if (aspect != null && !aspect.isEmpty()) {
-        autoProvidesAspects.add(aspect);
+        scopeProvides.add(Util.wrapAspect(aspect));
       }
       final var forExternal = metaData.autoProvides();
       if (forExternal != null && !forExternal.isEmpty()) {
-        autoProvides.addAll(forExternal);
+        scopeProvides.addAll(forExternal);
       }
     }
-    if (!autoProvides.isEmpty()) {
-      scopeInfo.buildAutoProvides(writer, autoProvides);
-    }
-    if (!autoProvidesAspects.isEmpty()) {
-      scopeInfo.buildAutoProvidesAspects(writer, autoProvidesAspects);
-    }
-    Set<String> autoRequires = ordering.autoRequires();
-    if (!autoRequires.isEmpty()) {
-      scopeInfo.buildAutoRequires(writer, autoRequires);
-    }
-    Set<String> autoRequiresAspects = ordering.autoRequiresAspects();
-    if (!autoRequiresAspects.isEmpty()) {
-      scopeInfo.buildAutoRequiresAspects(writer, autoRequiresAspects);
-    }
+    Set<String> scopeRequires = new TreeSet<>(scopeInfo.requires());
+    scopeRequires.addAll(ordering.autoRequires());
+    scopeInfo.buildProvides(writer, scopeProvides, scopeRequires);
 
-    var requires = new ArrayList<>(scopeInfo.requires());
-    var provides = new ArrayList<>(scopeInfo.provides());
-    requires.addAll(autoRequires);
-    autoRequiresAspects.stream().map(Util::wrapAspect).forEach(requires::add);
-    provides.addAll(autoProvides);
-    autoProvidesAspects.stream().map(Util::wrapAspect).forEach(provides::add);
+    var requires = new ArrayList<>(scopeRequires);
+    var provides = new ArrayList<>(scopeProvides);
 
     ProcessingContext.addModule(new ModuleData(fullName, provides, requires));
   }
@@ -310,7 +303,6 @@ private void writeStartClass() {
     if (scopeInfo.addModuleConstructor()) {
       writeConstructor();
     }
-    scopeInfo.buildProvides(writer);
   }
 
   private void writeWithBeans() {

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

@@ -2,7 +2,7 @@
 
 import io.avaje.inject.Factory;
 import io.avaje.inject.InjectModule;
-@InjectModule(strictWiring = true)
+
+@InjectModule(strictWiring = true, providesString = "java.util.Queue<java.util.String>")
 @Factory
-public class _Wiring {
-}
+public class _Wiring {}

inject-gradle-plugin/build.gradle

@@ -6,15 +6,15 @@ plugins {
 }
 
 group 'io.avaje.inject'
-version '11.1'
+version '11.6-RC4'
 
 repositories {
   mavenLocal()
   mavenCentral()
 }
 
 dependencies {
-  implementation 'io.avaje:avaje-inject:11.1'
+  implementation 'io.avaje:avaje-inject:11.6-RC4'
   implementation gradleApi()
 
   testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'