Refactor annotation processing (#1341)

Author: nakamura-to

.sdkmanrc

@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=17.0.14-tem
+java=17.0.15-tem

doma-processor/src/main/java/org/seasar/doma/internal/apt/DomaProcessor.java

@@ -25,8 +25,8 @@
 import static org.seasar.doma.internal.apt.AnnotationTypes.EXTERNAL_DOMAIN;
 import static org.seasar.doma.internal.apt.AnnotationTypes.SCOPE;
 
-import java.util.List;
-import java.util.Objects;
+import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
 import javax.annotation.processing.AbstractProcessor;
@@ -81,17 +81,17 @@
 })
 public class DomaProcessor extends AbstractProcessor {
 
-  private static final List<Operator> operators =
-      List.of(
-          new Operator(EXTERNAL_DOMAIN, ExternalDomainProcessor::new),
-          new Operator(DATA_TYPE, DataTypeProcessor::new),
-          new Operator(DOMAIN, DomainProcessor::new),
-          new Operator(DOMAIN_CONVERTERS, DomainConvertersProcessor::new),
-          new Operator(EMBEDDABLE, EmbeddableProcessor::new),
-          new Operator(ENTITY, EntityProcessor::new),
-          new Operator(AGGREGATE_STRATEGY, AggregateStrategyProcessor::new),
-          new Operator(DAO, DaoProcessor::new),
-          new Operator(SCOPE, ScopeProcessor::new));
+  private static final Map<String, Function<RoundContext, ElementProcessor>> functionMap =
+      Map.of(
+          EXTERNAL_DOMAIN, ExternalDomainProcessor::new,
+          DATA_TYPE, DataTypeProcessor::new,
+          DOMAIN, DomainProcessor::new,
+          DOMAIN_CONVERTERS, DomainConvertersProcessor::new,
+          EMBEDDABLE, EmbeddableProcessor::new,
+          ENTITY, EntityProcessor::new,
+          AGGREGATE_STRATEGY, AggregateStrategyProcessor::new,
+          DAO, DaoProcessor::new,
+          SCOPE, ScopeProcessor::new);
 
   private ProcessingContext processingContext;
 
@@ -113,24 +113,39 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
       return true;
     }
 
-    var roundContext = processingContext.createRoundContext(annotations, roundEnv);
+    var roundContext = processingContext.createRoundContext(roundEnv);
 
-    for (var operator : operators) {
-      var elements = roundContext.getElementsAnnotatedWith(operator.annotationName);
-      if (!elements.isEmpty()) {
-        var processor = operator.function.apply(roundContext);
-        processor.process(elements);
+    var externalDomainAnnotation = new HashSet<TypeElement>(1);
+    var otherAnnotations = new HashSet<TypeElement>(functionMap.size() - 1);
+
+    for (var annotation : annotations) {
+      if (annotation.getQualifiedName().contentEquals(EXTERNAL_DOMAIN)) {
+        externalDomainAnnotation.add(annotation);
+      } else {
+        otherAnnotations.add(annotation);
       }
     }
 
+    // process ExternalDomain annotation first
+    processWithRoundContext(externalDomainAnnotation, roundContext);
+
+    // process other annotations
+    processWithRoundContext(otherAnnotations, roundContext);
+
     return true;
   }
 
-  private record Operator(
-      String annotationName, Function<RoundContext, ElementProcessor> function) {
-    Operator {
-      Objects.requireNonNull(annotationName);
-      Objects.requireNonNull(function);
+  private void processWithRoundContext(Set<TypeElement> annotations, RoundContext roundContext) {
+    for (var annotation : annotations) {
+      String annotationName = annotation.getQualifiedName().toString();
+      var function = functionMap.get(annotationName);
+      if (function != null) {
+        var elements = roundContext.getElementsAnnotatedWith(annotation);
+        if (!elements.isEmpty()) {
+          var processor = function.apply(roundContext);
+          processor.process(elements);
+        }
+      }
     }
   }
 }

doma-processor/src/main/java/org/seasar/doma/internal/apt/ProcessingContext.java

@@ -16,10 +16,8 @@
 package org.seasar.doma.internal.apt;
 
 import java.util.Objects;
-import java.util.Set;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.annotation.processing.RoundEnvironment;
-import javax.lang.model.element.TypeElement;
 
 public class ProcessingContext {
 
@@ -68,11 +66,9 @@ private boolean isDebug(ProcessingEnvironment env) {
     return Boolean.parseBoolean(debug);
   }
 
-  public RoundContext createRoundContext(
-      Set<? extends TypeElement> annotationElements, RoundEnvironment roundEnvironment) {
-    Objects.requireNonNull(annotationElements);
+  public RoundContext createRoundContext(RoundEnvironment roundEnvironment) {
     Objects.requireNonNull(roundEnvironment);
-    var roundContext = new RoundContext(this, roundEnvironment, annotationElements);
+    var roundContext = new RoundContext(this, roundEnvironment);
     roundContext.init();
     return roundContext;
   }

doma-processor/src/main/java/org/seasar/doma/internal/apt/RoundContext.java

@@ -31,21 +31,16 @@ public class RoundContext {
 
   private final ProcessingContext processingContext;
   private final RoundEnvironment roundEnvironment;
-  private final Set<? extends TypeElement> annotationElements;
   private final List<ExternalDomainMeta> externalDomainMetaList = new ArrayList<>();
   private boolean initialized;
   private Annotations annotations;
   private Declarations declarations;
   private CtTypes ctTypes;
   private Names names;
 
-  RoundContext(
-      ProcessingContext processingContext,
-      RoundEnvironment roundEnvironment,
-      Set<? extends TypeElement> annotationElements) {
+  RoundContext(ProcessingContext processingContext, RoundEnvironment roundEnvironment) {
     this.processingContext = Objects.requireNonNull(processingContext);
     this.roundEnvironment = Objects.requireNonNull(roundEnvironment);
-    this.annotationElements = Objects.requireNonNull(annotationElements);
   }
 
   void init() {
@@ -114,14 +109,10 @@ public List<ExternalDomainMeta> getExternalDomainMetaList() {
     return externalDomainMetaList;
   }
 
-  public Set<? extends Element> getElementsAnnotatedWith(String annotationName) {
+  public Set<? extends Element> getElementsAnnotatedWith(TypeElement annotation) {
     assertInitialized();
-    Objects.requireNonNull(annotationName);
-    return annotationElements.stream()
-        .filter(a -> a.getQualifiedName().contentEquals(annotationName))
-        .findFirst()
-        .map(roundEnvironment::getElementsAnnotatedWith)
-        .orElse(Set.of());
+    Objects.requireNonNull(annotation);
+    return roundEnvironment.getElementsAnnotatedWith(annotation);
   }
 
   private void assertInitialized() {

doma-processor/src/test/java/org/seasar/doma/internal/apt/TestProcessor.java

@@ -66,7 +66,7 @@ public boolean process(
     if (roundEnv.processingOver() || handled) {
       return true;
     }
-    RoundContext roundContext = ctx.createRoundContext(annotations, roundEnv);
+    RoundContext roundContext = ctx.createRoundContext(roundEnv);
     run(roundContext);
     handled = true;
     return false;

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/MyAnnotationProcessor.java

@@ -57,8 +57,8 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
     if (roundEnv.processingOver()) {
       return true;
     }
-    var roundContext = ctx.createRoundContext(annotations, roundEnv);
-    var elements = roundContext.getElementsAnnotatedWith(MyAnnotation.class.getName());
+    var roundContext = ctx.createRoundContext(roundEnv);
+    var elements = roundContext.getElementsAnnotatedWith(annotations.iterator().next());
     var processor = new MyElementProcessor(roundContext, handler);
     processor.process(elements);
     return true;