fix field assisted inject

Author: SentryMan

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

@@ -1,10 +1,14 @@
 package io.avaje.inject.generator;
 
+import static java.util.stream.Collectors.toList;
+
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 
 import javax.lang.model.element.*;
+import javax.lang.model.util.ElementFilter;
 
 import io.avaje.inject.generator.MethodReader.MethodParam;
 
@@ -23,7 +27,7 @@ final class AssistBeanReader {
   private final TypeReader typeReader;
   private final TypeElement targetType;
   private final String qualifierName;
-  private ExecutableElement factoryMethod;
+  private final ExecutableElement factoryMethod;
 
   AssistBeanReader(TypeElement beanType) {
     this.beanType = beanType;
@@ -38,35 +42,80 @@ final class AssistBeanReader {
     this.constructor = typeReader.constructor();
 
     AssistFactoryPrism instanceOn = AssistFactoryPrism.getInstanceOn(beanType);
-    targetType = APContext.asTypeElement(instanceOn.value());
-    validateTarget(targetType);
-
-    for (Element enclosedElement : targetType.getEnclosedElements()) {
-      if (enclosedElement.getKind() == ElementKind.METHOD) {
-        factoryMethod = (ExecutableElement) enclosedElement;
-      }
-    }
+    var factoryType = APContext.asTypeElement(instanceOn.value());
 
     constructor.params().stream()
-      .filter(MethodParam::assisted)
-      .map(MethodParam::element)
-      .forEach(assistedElements::add);
+        .filter(MethodParam::assisted)
+        .map(MethodParam::element)
+        .forEach(assistedElements::add);
     injectFields.stream()
-      .filter(FieldReader::assisted)
-      .map(FieldReader::element)
-      .forEach(assistedElements::add);
+        .filter(FieldReader::assisted)
+        .map(FieldReader::element)
+        .forEach(assistedElements::add);
     injectMethods.stream()
-      .map(MethodReader::params)
-      .flatMap(List::stream)
-      .filter(MethodParam::assisted)
-      .map(MethodParam::element)
-      .forEach(assistedElements::add);
+        .map(MethodReader::params)
+        .flatMap(List::stream)
+        .filter(MethodParam::assisted)
+        .map(MethodParam::element)
+        .forEach(assistedElements::add);
+
+    factoryMethod =
+        ElementFilter.methodsIn(factoryType.getEnclosedElements()).stream()
+            .filter(e -> e.getModifiers().contains(Modifier.ABSTRACT))
+            .findFirst()
+            .orElse(null);
+
+    if (!factoryType.getQualifiedName().contentEquals("java.lang.Void")) {
+      validateTarget(factoryType);
+      this.targetType = factoryType;
+    } else {
+      targetType = null;
+    }
   }
 
   private void validateTarget(TypeElement t) {
-    if (t.getKind() != ElementKind.INTERFACE || !t.getModifiers().contains(Modifier.ABSTRACT)) {
-      APContext.logError(type, "@AssistFactory targets must be abstract");
+    var methods = ElementFilter.methodsIn(t.getEnclosedElements());
+    if (!APContext.elements().isFunctionalInterface(t)) {
+      if (!t.getModifiers().contains(Modifier.ABSTRACT)) {
+        APContext.logError(type, "@AssistFactory targets must be abstract");
+      } else if (methods.stream()
+              .filter(e -> e.getModifiers().contains(Modifier.ABSTRACT))
+              .collect(toList())
+              .size()
+          != 1) {
+        APContext.logError(type, "@AssistFactory targets must have only one abstract method");
+      }
+    }
+    var sb =
+        new StringBuilder(
+            String.format(
+                "@AssistFactory targets for type %s must have an abstract method with form '%s <methodName>(",
+                shortName(), shortName()));
+
+    for (var iterator = assistedElements.iterator(); iterator.hasNext(); ) {
+      var element = iterator.next();
+
+      var typeName = UType.parse(element.asType());
+
+      sb.append(
+          String.format("%s %s", typeName.shortWithoutAnnotations(), element.getSimpleName()));
+      if (iterator.hasNext()) {
+        sb.append(", ");
+      }
     }
+    var errorMsg = sb.append(")' method.").toString();
+
+    Optional.of(factoryMethod).stream()
+        .map(ExecutableElement::getParameters)
+        .findAny()
+        .ifPresentOrElse(
+            params -> {
+              var mismatched = params.size() != assistedElements.size();
+              if (mismatched) {
+                APContext.logError(t, errorMsg);
+              }
+            },
+            () -> APContext.logError(t, errorMsg));
   }
 
   @Override

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

@@ -229,9 +229,14 @@ private void injectFields() {
       writer.indent("    ").append("bean.%s = %s;", fieldName, getDependency).eol();
     }
 
-    for (var field : assistedElements) {
-      writer.indent("    ").append("bean.%s = %s;", field.getSimpleName(), field.getSimpleName()).eol();
-    }
+    assistedElements.stream()
+        .filter(e -> e.getKind() == ElementKind.FIELD)
+        .forEach(
+            field ->
+                writer
+                    .indent("    ")
+                    .append("bean.%s = %s;", field.getSimpleName(), field.getSimpleName())
+                    .eol());
   }
 
   private void injectMethods() {

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

@@ -0,0 +1,22 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+import java.util.List;
+
+import io.avaje.inject.AssistFactory;
+import io.avaje.inject.Assisted;
+import io.avaje.lang.Nullable;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+
+@Named("tomato")
+@AssistFactory(CarFactory.class)
+public class Car {
+
+  @Assisted List<String> type;
+  @Inject Wheel wheel;
+
+  public Car(@Assisted Paint paint, @Nullable Engine engine) {}
+
+  @Inject
+  void injectMethod(@Assisted int size, Model m) {}
+}

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

@@ -0,0 +1,7 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+import java.util.List;
+
+public interface CarFactory {
+  Car construct(Paint paint, int size, List<String> type);
+}

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

@@ -0,0 +1,6 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+import jakarta.inject.Singleton;
+
+@Singleton
+public class Engine {}

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

@@ -0,0 +1,6 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+import jakarta.inject.Singleton;
+
+@Singleton
+public class Model {}

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

@@ -0,0 +1,3 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+public interface Paint {}

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

@@ -0,0 +1,6 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+import jakarta.inject.Singleton;
+
+@Singleton
+public class Radio {}

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

@@ -0,0 +1,6 @@
+package io.avaje.inject.generator.models.valid.assist;
+
+import jakarta.inject.Singleton;
+
+@Singleton
+public class Wheel {}

inject/src/main/java/io/avaje/inject/AssistFactory.java

@@ -6,42 +6,37 @@
 import java.lang.annotation.Target;
 
 /**
- * Annotate a bean which we want avaje-inject to generate the factory for.
- * <p>
- * The bean will have some properties that are normal dependency injection
- * components that will be injected and others that will be parameters
- * to the method on the factory - these parameters are annotated with
+ * Annotate a bean for which we want avaje-inject to generate a factory.
+ *
+ * <p>The bean will have some properties of normal dependency injection components and others that
+ * will be parameters to the method on the factory - these parameters are annotated with
  * {@code @Assisted}.
  *
  * <h3>Example</h3>
- * <p>
- * Have an interface which we want avaje-inject to generate an implementation.
- * We desire this because the factory has some dependencies that are components
- * that avaje-inject should inject for us and some other dependencies that are
- * provided by the application (and annotated with {@code Assisted}).
- * <p>
- * The factory interface must only have 1 method defined.
  *
- * <pre>{@code
+ * <p>Create an interface which we want avaje-inject to generate an implementation. We desire this
+ * because the factory has some managed dependencies that should be injected for us and some
+ * dependencies that are provided by the application (and annotated with {@code Assisted}).
  *
+ * <p>The factory interface must be a functional interface, or an abstract class with only one
+ * abstract method defined.
+ *
+ * <pre>{@code
  * public interface CssFactory {
  *
  *   Scanner scanner(Path myPath);
  * }
  *
  * }</pre>
- * <p>
- * Have a bean annotated with {@code @AssistFactory} that specifies the factory.
- * Any dependencies that are annotated with {@code Assisted} will be parameters
- * of the factory method, the other dependencies are normal components that
- * will be injected.
- * <p>
- * The {@code Assisted} parameters must match the factory method parameters
- * by name and type. In this example {@code Path myPath} match in both CssScanner
- * and in CssFactory.
  *
- * <pre>{@code
+ * <p>Create a bean annotated with {@code @AssistFactory} that specifies the factory. Any
+ * dependencies that are annotated with {@code Assisted} will be parameters of the factory method,
+ * the other dependencies will be managed and injected by avaje-inject.
+ *
+ * <p>The {@code Assisted} parameters must match the factory method parameters by name and type. In
+ * this example, {@code Path myPath} match in both CssScanner and in CssFactory.
  *
+ * <pre>{@code
  * @AssistFactory(CssFactory.class)
  * class CssScanner implements Scanner {
  *
@@ -62,8 +57,6 @@
 @Retention(RetentionPolicy.RUNTIME)
 public @interface AssistFactory {
 
-  /**
-   * Specify the factory interface for which the implementation will be generated.
-   */
+  /** Specify the factory interface for which the implementation will be generated. */
   Class<?> value();
 }