Refactor annotation processing (#1342)

Author: nakamura-to

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

@@ -25,10 +25,11 @@
 import static org.seasar.doma.internal.apt.AnnotationTypes.EXTERNAL_DOMAIN;
 import static org.seasar.doma.internal.apt.AnnotationTypes.SCOPE;
 
-import java.util.HashSet;
-import java.util.Map;
+import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import javax.annotation.processing.AbstractProcessor;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.annotation.processing.RoundEnvironment;
@@ -81,25 +82,24 @@
 })
 public class DomaProcessor extends AbstractProcessor {
 
-  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 static final List<Operation> operations =
+      List.of(
+          new Operation(EXTERNAL_DOMAIN, ExternalDomainProcessor::new),
+          new Operation(DATA_TYPE, DataTypeProcessor::new),
+          new Operation(DOMAIN, DomainProcessor::new),
+          new Operation(DOMAIN_CONVERTERS, DomainConvertersProcessor::new),
+          new Operation(EMBEDDABLE, EmbeddableProcessor::new),
+          new Operation(ENTITY, EntityProcessor::new),
+          new Operation(AGGREGATE_STRATEGY, AggregateStrategyProcessor::new),
+          new Operation(DAO, DaoProcessor::new),
+          new Operation(SCOPE, ScopeProcessor::new));
 
   private ProcessingContext processingContext;
 
   @Override
   public synchronized void init(ProcessingEnvironment processingEnv) {
     super.init(processingEnv);
-    processingContext = new ProcessingContext(processingEnv);
-    processingContext.init();
+    processingContext = ProcessingContext.of(processingEnv);
   }
 
   @Override
@@ -115,37 +115,32 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
 
     var roundContext = processingContext.createRoundContext(roundEnv);
 
-    var externalDomainAnnotation = new HashSet<TypeElement>(1);
-    var otherAnnotations = new HashSet<TypeElement>(functionMap.size() - 1);
+    var annotationMap =
+        annotations.stream()
+            .collect(
+                Collectors.toUnmodifiableMap(
+                    it -> it.getQualifiedName().toString(), Function.identity()));
 
-    for (var annotation : annotations) {
-      if (annotation.getQualifiedName().contentEquals(EXTERNAL_DOMAIN)) {
-        externalDomainAnnotation.add(annotation);
-      } else {
-        otherAnnotations.add(annotation);
+    for (var operation : operations) {
+      var annotation = annotationMap.get(operation.name);
+      if (annotation == null) {
+        continue;
       }
+      var elements = roundContext.getElementsAnnotatedWith(annotation);
+      if (elements.isEmpty()) {
+        continue;
+      }
+      var processor = operation.function.apply(roundContext);
+      processor.process(elements);
     }
 
-    // process ExternalDomain annotation first
-    processWithRoundContext(externalDomainAnnotation, roundContext);
-
-    // process other annotations
-    processWithRoundContext(otherAnnotations, roundContext);
-
     return true;
   }
 
-  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);
-        }
-      }
+  private record Operation(String name, Function<RoundContext, ElementProcessor> function) {
+    Operation {
+      Objects.requireNonNull(name);
+      Objects.requireNonNull(function);
     }
   }
 }

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

@@ -30,11 +30,11 @@ public class ProcessingContext {
   private Reporter reporter;
   private Resources resources;
 
-  public ProcessingContext(ProcessingEnvironment env) {
+  private ProcessingContext(ProcessingEnvironment env) {
     this.env = Objects.requireNonNull(env);
   }
 
-  public void init() {
+  private void init() {
     if (initialized) {
       throw new AptIllegalStateException("already initialized");
     }
@@ -103,4 +103,11 @@ private void assertInitialized() {
       throw new AptIllegalStateException("not yet initialized");
     }
   }
+
+  public static ProcessingContext of(ProcessingEnvironment env) {
+    Objects.requireNonNull(env);
+    var processingContext = new ProcessingContext(env);
+    processingContext.init();
+    return processingContext;
+  }
 }

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

@@ -41,8 +41,7 @@ protected TestProcessor() {}
   @Override
   public synchronized void init(ProcessingEnvironment env) {
     super.init(env);
-    ctx = new ProcessingContext(env);
-    ctx.init();
+    ctx = ProcessingContext.of(env);
   }
 
   @Override

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

@@ -38,8 +38,7 @@ public MyAnnotationProcessor(Function<TypeElement, NullElementMeta> handler) {
   @Override
   public synchronized void init(ProcessingEnvironment processingEnv) {
     super.init(processingEnv);
-    this.ctx = new ProcessingContext(processingEnv);
-    ctx.init();
+    this.ctx = ProcessingContext.of(processingEnv);
   }
 
   @Override