Add @BeanTypes Annotation to Limit Injection Types

blackbox-test-inject/src/main/java/org/example/myapp/beantypes/AbstractSuperClass.java

@@ -0,0 +1,3 @@
+package org.example.myapp.beantypes;
+
+public abstract class AbstractSuperClass {}

blackbox-test-inject/src/main/java/org/example/myapp/beantypes/BeanTypeComponent.java

@@ -0,0 +1,14 @@
+package org.example.myapp.beantypes;
+
+import org.example.myapp.config.AppConfig.SomeInterface;
+import org.other.one.SomeOptionalDep;
+
+import io.avaje.inject.BeanTypes;
+import io.avaje.inject.Component;
+import jakarta.inject.Named;
+
+@Component
+@Named("type")
+@BeanTypes(AbstractSuperClass.class)
+public class BeanTypeComponent extends AbstractSuperClass
+    implements SomeInterface, SomeOptionalDep, LimitedInterface {}

blackbox-test-inject/src/main/java/org/example/myapp/beantypes/LimitedFactory.java

@@ -0,0 +1,17 @@
+package org.example.myapp.beantypes;
+
+import io.avaje.inject.Bean;
+import io.avaje.inject.BeanTypes;
+import io.avaje.inject.Factory;
+import jakarta.inject.Named;
+
+@Factory
+public class LimitedFactory {
+
+  @Bean
+  @Named("factory")
+  @BeanTypes(LimitedInterface.class)
+  BeanTypeComponent bean() {
+    return new BeanTypeComponent();
+  }
+}

blackbox-test-inject/src/main/java/org/example/myapp/beantypes/LimitedInterface.java

@@ -0,0 +1,3 @@
+package org.example.myapp.beantypes;
+
+public interface LimitedInterface {}

blackbox-test-inject/src/test/java/org/example/myapp/beantypes/BeanTypeComponentTest.java

@@ -0,0 +1,21 @@
+package org.example.myapp.beantypes;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.junit.jupiter.api.Test;
+
+import io.avaje.inject.BeanScope;
+
+class BeanTypesTest {
+
+  @Test
+  void testBeanTypesRestrictingInjection() {
+    try (var scope = BeanScope.builder().build()) {
+
+      assertFalse(scope.contains(BeanTypeComponent.class));
+      assertThat(scope.get(AbstractSuperClass.class)).isNotNull();
+      assertThat(scope.get(LimitedInterface.class)).isNotNull();
+    }
+  }
+}

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

@@ -33,7 +33,13 @@ final class AssistBeanReader {
   AssistBeanReader(TypeElement beanType) {
     this.beanType = beanType;
     this.type = beanType.getQualifiedName().toString();
-    this.typeReader = new TypeReader(UType.parse(beanType.asType()), beanType, importTypes, false);
+    this.typeReader =
+      new TypeReader(
+        Optional.empty(),
+        UType.parse(beanType.asType()),
+        beanType,
+        importTypes,
+        false);
 
     typeReader.process();
     qualifierName = typeReader.name();

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

@@ -58,7 +58,15 @@ final class BeanReader {
     this.primary = PrimaryPrism.isPresent(beanType);
     this.secondary = !primary && SecondaryPrism.isPresent(beanType);
     this.lazy = !FactoryPrism.isPresent(beanType) && LazyPrism.isPresent(beanType);
-    this.typeReader = new TypeReader(UType.parse(beanType.asType()), beanType, importTypes, factory);
+    final var beantypes = BeanTypesPrism.getOptionalOn(beanType);
+    beantypes.ifPresent(p -> Util.validateBeanTypes(beanType, p.value()));
+    this.typeReader =
+      new TypeReader(
+        beantypes,
+        UType.parse(beanType.asType()),
+        beanType,
+        importTypes,
+        factory);
 
     typeReader.process();
 

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

@@ -95,7 +95,9 @@ final class MethodReader {
       this.initMethod = initMethod;
       this.destroyMethod = destroyMethod;
     } else {
-      this.typeReader = new TypeReader(genericType, returnElement, importTypes);
+      final var beantypes = BeanTypesPrism.getOptionalOn(element);
+      beantypes.ifPresent(p -> Util.validateBeanTypes(element, p.value()));
+      this.typeReader = new TypeReader(beantypes, genericType, returnElement, importTypes);
       typeReader.process();
       MethodLifecycleReader lifecycleReader = new MethodLifecycleReader(returnElement, initMethod, destroyMethod);
       this.initMethod = lifecycleReader.initMethod();

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

@@ -3,10 +3,11 @@
 import javax.lang.model.element.Element;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
-
 import static java.util.stream.Collectors.toList;
 
 final class TypeReader {
@@ -18,16 +19,37 @@ final class TypeReader {
   private final TypeAnnotationReader annotationReader;
   private Set<UType> genericTypes;
   private String typesRegister;
-
-  TypeReader(UType genericType, TypeElement beanType, ImportTypeMap importTypes, boolean factory) {
-    this(genericType, true, beanType, importTypes, factory);
-  }
-
-  TypeReader(UType genericType, TypeElement returnElement, ImportTypeMap importTypes) {
-    this(genericType, false, returnElement, importTypes, false);
-  }
-
-  private TypeReader(UType genericType, boolean forBean, TypeElement beanType, ImportTypeMap importTypes, boolean factory) {
+  private final List<UType> injectsTypes;
+
+  TypeReader(
+      Optional<BeanTypesPrism> injectsTypes,
+      UType genericType,
+      TypeElement beanType,
+      ImportTypeMap importTypes,
+      boolean factory) {
+    this(injectsTypes, genericType, true, beanType, importTypes, factory);
+  }
+
+  TypeReader(
+      Optional<BeanTypesPrism> injectsTypes,
+      UType genericType,
+      TypeElement returnElement,
+      ImportTypeMap importTypes) {
+    this(injectsTypes, genericType, false, returnElement, importTypes, false);
+  }
+
+  private TypeReader(
+      Optional<BeanTypesPrism> injectsTypes,
+      UType genericType,
+      boolean forBean,
+      TypeElement beanType,
+      ImportTypeMap importTypes,
+      boolean factory) {
+    this.injectsTypes =
+      injectsTypes.map(BeanTypesPrism::value).stream()
+        .flatMap(List::stream)
+        .map(UType::parse)
+        .collect(toList());
     this.forBean = forBean;
     this.beanType = beanType;
     this.importTypes = importTypes;
@@ -41,14 +63,20 @@ String typesRegister() {
   }
 
   List<String> provides() {
+    if (!injectsTypes.isEmpty()) {
+      return injectsTypes.stream().map(UType::full).collect(toList());
+    }
     return extendsReader.provides().stream().map(UType::full).collect(toList());
   }
 
   List<String> autoProvides() {
+    if (!injectsTypes.isEmpty()) {
+      return injectsTypes.stream().map(UType::full).collect(toList());
+    }
     return extendsReader.autoProvides().stream()
-        .filter(u -> u.componentTypes().stream().noneMatch(p -> p.kind() == TypeKind.TYPEVAR))
-        .map(UType::full)
-        .collect(toList());
+      .filter(u -> u.componentTypes().stream().noneMatch(p -> p.kind() == TypeKind.TYPEVAR))
+      .map(UType::full)
+      .collect(toList());
   }
 
   String providesAspect() {
@@ -120,8 +148,12 @@ String name() {
 
   private void initRegistrationTypes() {
     TypeAppender appender = new TypeAppender(importTypes);
-    appender.add(extendsReader.baseType());
-    appender.add(extendsReader.provides());
+    if (injectsTypes.isEmpty()) {
+      appender.add(extendsReader.baseType());
+      appender.add(extendsReader.provides());
+    } else {
+      appender.add(injectsTypes);
+    }
     this.genericTypes = appender.genericTypes();
     this.typesRegister = appender.asString();
   }

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

@@ -2,7 +2,9 @@
 
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
@@ -377,4 +379,16 @@ static String valhalla() {
     }
     return "";
   }
+
+  static void validateBeanTypes(Element origin, List<TypeMirror> beanType) {
+    TypeMirror targetType =
+      origin instanceof TypeElement
+        ? origin.asType()
+        : ((ExecutableElement) origin).getReturnType();
+    beanType.forEach(type -> {
+      if (!APContext.types().isAssignable(targetType, type)) {
+        APContext.logError(origin, "%s does not extend type %s", targetType, beanType);
+      }
+    });
+  }
 }

inject-generator/src/main/java/io/avaje/inject/generator/package-info.java

@@ -12,6 +12,7 @@
 @GeneratePrism(Generated.class)
 @GeneratePrism(Inject.class)
 @GeneratePrism(InjectModule.class)
+@GeneratePrism(BeanTypes.class)
 @GeneratePrism(Lazy.class)
 @GeneratePrism(Named.class)
 @GeneratePrism(PreDestroy.class)

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

@@ -0,0 +1,15 @@
+package io.avaje.inject.generator.models.valid.supertypes;
+
+import io.avaje.inject.Bean;
+import io.avaje.inject.BeanTypes;
+import io.avaje.inject.Factory;
+
+@Factory
+public class LimitedFactory {
+
+  @Bean
+  @BeanTypes(SomeInterface.class)
+  OtherComponent bean() {
+    return new OtherComponent();
+  }
+}

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

@@ -0,0 +1,9 @@
+package io.avaje.inject.generator.models.valid.supertypes;
+
+import io.avaje.inject.BeanTypes;
+import io.avaje.inject.Component;
+
+@Component
+@BeanTypes(SomeInterface2.class)
+public class LimitedOtherComponent extends AbstractSuperClass
+    implements SomeInterface, SomeInterface2 {}

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

@@ -0,0 +1,11 @@
+package io.avaje.inject;
+
+import java.lang.annotation.*;
+
+/** Limits the types exposed by this bean to the given types. */
+@Retention(RetentionPolicy.SOURCE)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface BeanTypes {
+
+  Class<?>[] value();
+}