Use strings for provides/requires (#835)

* use strings for provides/requires

this prevents issues where auto provided/required types not available during compilation or plugin activation fail builds

* allow generics in `@InjectModule`

* gradle

* separate generics in generated annotation

Author: SentryMan

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,22 @@ 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());
-      }
-      for (final var provide : module.autoProvidesAspects()) {
-        final var aspectType = Util.wrapAspect(provide.getTypeName());
+      Collections.addAll(provides, module.providesBeans());
+      Collections.addAll(provides, module.autoProvidesBeans());
+      for (final var provide : module.autoProvidesAspectBeans()) {
+        final var aspectType = Util.wrapAspect(provide);
         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.autoRequiresBeans());
+      Collections.addAll(requires, module.requiresPackagesFromType());
+      Arrays.stream(module.autoRequiresAspectBeans())
+          .map(Util::wrapAspect)
+          .forEach(requires::add);
 
       ProcessingContext.addModule(new ModuleData(name, List.copyOf(provides), requires));
     }

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()) {
-      attributeClasses(false, writer, "provides", provides);
+    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", regularProvides);
       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,22 @@ 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(", ");
     }
@@ -429,32 +476,26 @@ private void attributeClasses(boolean leadingComma, Append writer, String prefix
 
   void buildProvides(Append writer) {
     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();
@@ -463,28 +504,28 @@ private void buildProvidesMethod(Append writer, String fieldName, Set<String> ty
   void buildAutoProvides(Append writer, Set<String> autoProvides) {
     autoProvides.removeAll(provides);
     if (!autoProvides.isEmpty()) {
-      buildProvidesMethod(writer, "autoProvides", autoProvides);
+      buildProvidesMethod(writer, "autoProvidesBeans", autoProvides);
     }
   }
 
   void buildAutoProvidesAspects(Append writer, Set<String> autoProvidesAspects) {
     autoProvidesAspects.removeAll(provides);
     if (!autoProvidesAspects.isEmpty()) {
-      buildProvidesMethod(writer, "autoProvidesAspects", autoProvidesAspects);
+      buildProvidesMethod(writer, "autoProvidesAspectBeans", autoProvidesAspects);
     }
   }
 
   void buildAutoRequires(Append writer, Set<String> autoRequires) {
     autoRequires.removeAll(requires);
     if (!autoRequires.isEmpty()) {
-      buildProvidesMethod(writer, "autoRequires", autoRequires);
+      buildProvidesMethod(writer, "autoRequiresBeans", autoRequires);
     }
   }
 
   void buildAutoRequiresAspects(Append writer, Set<String> autoRequires) {
     autoRequires.removeAll(requires);
     if (!autoRequires.isEmpty()) {
-      buildProvidesMethod(writer, "autoRequiresAspects", autoRequires);
+      buildProvidesMethod(writer, "autoRequiresAspectBeans", autoRequires);
     }
   }
 

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;
 

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'

inject-gradle-plugin/src/main/java/io/avaje/inject/plugin/AvajeInjectPlugin.java

@@ -49,8 +49,8 @@ private void writeProvides(Project project) {
     try (var classLoader = classLoader(project);
         var pluginWriter = createFileWriter(outputDir.getPath(), "avaje-plugins.csv");
         var moduleCSV = createFileWriter(outputDir.getPath(), "avaje-module-dependencies.csv")) {
-        writeProvidedPlugins(classLoader, pluginWriter);
-        writeModuleCSV(classLoader, moduleCSV);
+      writeProvidedPlugins(classLoader, pluginWriter);
+      writeModuleCSV(classLoader, moduleCSV);
     } catch (IOException e) {
       throw new GradleException("Failed to write avaje-module-provides", e);
     }
@@ -115,7 +115,8 @@ private URLClassLoader classLoader(Project project) {
 
   private static URL[] createClassPath(Project project) {
     try {
-      Set<File> compileClasspath = project.getConfigurations().getByName("compileClasspath").resolve();
+      Set<File> compileClasspath =
+          project.getConfigurations().getByName("compileClasspath").resolve();
       final List<URL> urls = new ArrayList<>(compileClasspath.size());
       for (File file : compileClasspath) {
         urls.add(file.toURI().toURL());
@@ -140,25 +141,15 @@ private void writeModuleCSV(ClassLoader classLoader, FileWriter moduleWriter) th
       System.out.println("Detected External Module: " + name);
 
       final var provides = new ArrayList<String>();
-      for (final var provide : module.provides()) {
-        var type = provide.getTypeName();
+      for (final var provide : module.providesBeans()) {
+        var type = provide;
         provides.add(type);
       }
-      for (final var provide : module.autoProvides()) {
-        var type = provide.getTypeName();
-        provides.add(type);
-      }
-      for (final var provide : module.autoProvidesAspects()) {
-        var type = wrapAspect(provide.getTypeName());
-        provides.add(type);
-      }
-
-      final var requires = Arrays.<Type>stream(module.requires()).map(Type::getTypeName).collect(toList());
 
-      Arrays.<Type>stream(module.autoRequires()).map(Type::getTypeName).forEach(requires::add);
-      Arrays.<Type>stream(module.requiresPackages()).map(Type::getTypeName).forEach(requires::add);
-      Arrays.<Type>stream(module.autoRequiresAspects())
-          .map(Type::getTypeName)
+      final var requires = Arrays.stream(module.requiresBeans()).collect(toList());
+      Collections.addAll(requires, module.requiresPackagesFromType());
+      Arrays.stream(module.autoRequiresAspects())
+          .map(Class::getTypeName)
           .map(AvajeInjectPlugin::wrapAspect)
           .forEach(requires::add);
       modules.add(new ModuleData(name, provides, requires));

inject-maven-plugin/src/main/java/io/avaje/inject/mojo/AutoProvidesMojo.java

@@ -5,7 +5,6 @@
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.lang.reflect.Type;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
@@ -108,14 +107,15 @@ private void writeProvidedPlugins(URLClassLoader newClassLoader, FileWriter plug
     final Map<String, List<String>> pluginEntries = new HashMap<>();
     for (final var plugin : plugins) {
       final List<String> provides = new ArrayList<>();
-      final var typeName = plugin.getClass().getTypeName();
+      final var typeName = plugin.getClass();
       log.info("Loaded Plugin: " + typeName);
       for (final var provide : plugin.provides()) {
         provides.add(provide.getTypeName());
       }
       for (final var provide : plugin.providesAspects()) {
         provides.add(wrapAspect(provide.getCanonicalName()));
       }
+      pluginEntries.put(typeName.getTypeName(), provides);
       Optional.ofNullable(plugin.getClass().getAnnotation(PluginProvides.class))
         .ifPresent(p -> {
           for (final var provide : p.value()) {
@@ -127,7 +127,6 @@ private void writeProvidedPlugins(URLClassLoader newClassLoader, FileWriter plug
           }
           p.providesStrings();
         });
-      pluginEntries.put(typeName, provides);
     }
 
     pluginWriter.write("External Plugin Type|Provides");
@@ -151,35 +150,33 @@ private void writeModuleCSV(ClassLoader newClassLoader, FileWriter moduleWriter)
 
     List<ModuleData> modules = new ArrayList<>();
     for (final var module : avajeModules) {
-      final var name = module.getClass().getTypeName();
+      final var name = module.getClass();
       log.info("Detected External Module: " + name);
 
       final var provides = new ArrayList<String>();
-      for (final var provide : module.provides()) {
-        var type = provide.getTypeName();
+      for (final var provide : module.providesBeans()) {
+        var type = provide;
         provides.add(type);
       }
 
-      for (final var provide : module.autoProvides()) {
-        var type = provide.getTypeName();
+      for (final var provide : module.autoProvidesBeans()) {
+        var type = provide;
         provides.add(type);
       }
 
-      for (final var provide : module.autoProvidesAspects()) {
-        var type = wrapAspect(provide.getTypeName());
+      for (final var provide : module.autoProvidesAspectBeans()) {
+        var type = wrapAspect(provide);
         provides.add(type);
       }
 
-      final var requires =
-          Arrays.<Type>stream(module.requires()).map(Type::getTypeName).collect(toList());
+      final var requires = Arrays.stream(module.requiresBeans()).collect(toList());
 
-      Arrays.<Type>stream(module.autoRequires()).map(Type::getTypeName).forEach(requires::add);
-      Arrays.<Type>stream(module.requiresPackages()).map(Type::getTypeName).forEach(requires::add);
-      Arrays.<Type>stream(module.autoRequiresAspects())
-        .map(Type::getTypeName)
-        .map(AutoProvidesMojo::wrapAspect)
-        .forEach(requires::add);
-      modules.add(new ModuleData(name, provides, requires));
+      Collections.addAll(requires, module.autoRequiresBeans());
+      Collections.addAll(requires, module.requiresPackagesFromType());
+      Arrays.stream(module.autoRequiresAspectBeans())
+          .map(AutoProvidesMojo::wrapAspect)
+          .forEach(requires::add);
+      modules.add(new ModuleData(name.getTypeName(), provides, requires));
     }
 
     moduleWriter.write("External Module Type|Provides|Requires");