adds aspect import

Author: SentryMan

blackbox-aspect/src/main/java/org/example/external/aspect/MyExternalAspect.java

@@ -1,13 +1,11 @@
 package org.example.external.aspect;
 
-import io.avaje.inject.aop.Aspect;
-
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-@Aspect
+
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface MyExternalAspect {

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

@@ -1,7 +1,11 @@
 package org.example.myapp;
 
+import org.example.external.aspect.MyExternalAspect;
+
 import io.avaje.inject.BeanScope;
+import io.avaje.inject.aop.Aspect.Import;
 
+@Import(MyExternalAspect.class)
 public class Main {
 
   public static void main(String[] args) {
@@ -10,7 +14,7 @@ public static void main(String[] args) {
 
     HelloService helloService = beanScope.get(HelloService.class);
     String greeting = helloService.hello();
-    System.out.println("Greeting: "+greeting);
+    System.out.println("Greeting: " + greeting);
 
     assert greeting.equals("hello+AppHelloData");
   }

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

@@ -6,9 +6,12 @@
 import java.nio.file.NoSuchFileException;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 import javax.annotation.processing.Filer;
@@ -39,6 +42,7 @@ static final class Ctx {
     private final Set<String> uniqueModuleNames = new HashSet<>();
     private final Set<String> providedTypes = new HashSet<>();
     private final Set<String> optionalTypes = new LinkedHashSet<>();
+    private final Map<String, AspectImportPrism> aspectImportPrisms = new HashMap<>();
 
     public Ctx(ProcessingEnvironment processingEnv, Set<String> moduleFileProvided) {
 
@@ -172,6 +176,14 @@ static void addOptionalType(String paramType) {
     }
   }
 
+  static void addImportedAspects(Map<String, AspectImportPrism> importedMap) {
+    CTX.get().aspectImportPrisms.putAll(importedMap);
+  }
+
+  static Optional<AspectImportPrism> getImportedAspect(String type) {
+    return Optional.ofNullable(CTX.get().aspectImportPrisms.get(type));
+  }
+
   public static void clear() {
     CTX.remove();
   }

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

@@ -1,5 +1,6 @@
 package io.avaje.inject.generator;
 
+import static io.avaje.inject.generator.ProcessingContext.addImportedAspects;
 import static io.avaje.inject.generator.ProcessingContext.element;
 import static io.avaje.inject.generator.ProcessingContext.loadMetaInfCustom;
 import static io.avaje.inject.generator.ProcessingContext.loadMetaInfServices;
@@ -36,7 +37,8 @@
   Constants.SCOPE,
   Constants.TESTSCOPE,
   Constants.CONTROLLER,
-  ImportPrism.PRISM_TYPE
+  ImportPrism.PRISM_TYPE,
+  AspectImportPrism.PRISM_TYPE
 })
 public final class Processor extends AbstractProcessor {
 
@@ -97,6 +99,11 @@ private static String resource(Filer filer, String relativeName, String replace)
   @Override
   public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
     readModule(roundEnv);
+    final var importedAspects =
+        roundEnv.getElementsAnnotatedWith(element(AspectImportPrism.PRISM_TYPE)).stream()
+            .map(AspectImportPrism::getInstanceOn)
+            .collect(Collectors.toMap(p -> p.value().toString(), p -> p));
+    addImportedAspects(importedAspects);
     readScopes(roundEnv.getElementsAnnotatedWith(element(Constants.SCOPE)));
     readChangedBeans(roundEnv.getElementsAnnotatedWith(element(Constants.FACTORY)), true);
     if (defaultScope.includeSingleton()) {

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

@@ -1,5 +1,7 @@
 package io.avaje.inject.generator;
 
+import static io.avaje.inject.generator.ProcessingContext.getImportedAspect;
+
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
@@ -60,6 +62,9 @@ List<AspectPair> readAspects(Element element) {
       final var aspect = AspectPrism.getInstanceOn(anElement);
       if (aspect != null) {
         aspects.add(new AspectPair(anElement, aspect.ordering()));
+      } else {
+        getImportedAspect(anElement.asType().toString())
+            .ifPresent(p -> aspects.add(new AspectPair(anElement, p.ordering())));
       }
     }
     return aspects;

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

@@ -9,6 +9,7 @@
 @GeneratePrism(Named.class)
 @GeneratePrism(Inject.class)
 @GeneratePrism(Aspect.class)
+@GeneratePrism(value = Aspect.Import.class, name = "AspectImportPrism")
 @GeneratePrism(Primary.class)
 @GeneratePrism(Secondary.class)
 @GeneratePrism(Proxy.class)

inject/src/main/java/io/avaje/inject/aop/Aspect.java

@@ -1,16 +1,18 @@
 package io.avaje.inject.aop;
 
+import java.lang.annotation.Annotation;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
  * Meta annotation used to define an Aspect.
- * <p>
- * Create an annotation and annotate with {@code @Aspect} to define an aspect annotation. The
- * {@link Aspect#target()} specifies the associated type that implements {@link AspectProvider}.
- * The aspect provider should be a {@code @Singleton} such that registers with <em>avaje-inject</em>.
+ *
+ * <p>Create an annotation and annotate with {@code @Aspect} to define an aspect annotation. The
+ * associated type that implements {@link AspectProvider} will be used as the target class. The
+ * aspect provider should be a {@code @Singleton} such that registers with <em>avaje-inject</em>.
+ *
  * <p>
  */
 @Target(ElementType.ANNOTATION_TYPE)
@@ -19,20 +21,43 @@
 
   /**
    * Specify the priority ordering when multiple aspects are on a method.
-   * <p>
-   * When multiple aspects are on a method they are nested. The highest
-   * ordering value will be the outer-most aspect, the lowest ordering will
-   * be the inner-most aspect.
-   * <p>
-   * The outer-most aspect will have it's <em>before</em> executed first,
-   * followed by the <em>before</em> of the inner nested aspects ultimately
-   * down the invocation of the target method.
-   * <p>
-   * The reverse ordering occurs for <em>after</em> with the outer-most aspect
-   * having it's <em>after</em> executed last.
+   *
+   * <p>When multiple aspects are on a method they are nested. The highest ordering value will be
+   * the outer-most aspect, the lowest ordering will be the inner-most aspect.
+   *
+   * <p>The outer-most aspect will have it's <em>before</em> executed first, followed by the
+   * <em>before</em> of the inner nested aspects ultimately down the invocation of the target
+   * method.
+   *
+   * <p>The reverse ordering occurs for <em>after</em> with the outer-most aspect having it's
+   * <em>after</em> executed last.
    *
    * @return The ordering of this aspect. High value for outer-most aspect.
    */
   int ordering() default 1000;
 
+  /** Marks an External Annotation as being used for aspects */
+  @Target({ElementType.PACKAGE, ElementType.TYPE})
+  @Retention(RetentionPolicy.SOURCE)
+  public @interface Import {
+
+    Class<? extends Annotation> value();
+
+    /**
+     * Specify the priority ordering when multiple aspects are on a method.
+     *
+     * <p>When multiple aspects are on a method they are nested. The highest ordering value will be
+     * the outer-most aspect, the lowest ordering will be the inner-most aspect.
+     *
+     * <p>The outer-most aspect will have it's <em>before</em> executed first, followed by the
+     * <em>before</em> of the inner nested aspects ultimately down the invocation of the target
+     * method.
+     *
+     * <p>The reverse ordering occurs for <em>after</em> with the outer-most aspect having it's
+     * <em>after</em> executed last.
+     *
+     * @return The ordering of this aspect. High value for outer-most aspect.
+     */
+    int ordering() default 1000;
+  }
 }