remove: ResultType annotation

- make reactive support static
- fix #3717

Author: jknack

jooby/src/main/java/io/jooby/ReactiveSupport.java

@@ -8,7 +8,6 @@
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Flow;
 
-import io.jooby.annotation.ResultType;
 import io.jooby.internal.handler.ChunkedSubscriber;
 import io.jooby.internal.handler.ConcurrentHandler;
 
@@ -18,10 +17,6 @@
  * @author edgar
  * @since 3.0.0
  */
-@ResultType(
-    types = {Flow.Publisher.class, CompletionStage.class},
-    handler = "concurrent",
-    nonBlocking = true)
 public class ReactiveSupport {
 
   private static final Route.Filter CONCURRENT = new ConcurrentHandler();

jooby/src/main/java/io/jooby/annotation/ResultType.java

@@ -31,7 +31,6 @@
 import io.jooby.internal.apt.*;
 
 @SupportedOptions({
-  HANDLER,
   DEBUG,
   INCREMENTAL,
   MVC_METHOD,
@@ -42,7 +41,6 @@
 @SupportedSourceVersion(SourceVersion.RELEASE_17)
 public class JoobyProcessor extends AbstractProcessor {
   public interface Options {
-    String HANDLER = "jooby.handler";
     String DEBUG = "jooby.debug";
     String ROUTER_PREFIX = "jooby.routerPrefix";
     String ROUTER_SUFFIX = "jooby.routerSuffix";

modules/jooby-apt/src/main/java/io/jooby/apt/JoobyProcessor.java

@@ -9,11 +9,9 @@
 import java.io.StringWriter;
 import java.util.*;
 import java.util.function.BiConsumer;
-import java.util.stream.Collectors;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.*;
-import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeMirror;
 import javax.tools.Diagnostic;
 
@@ -24,8 +22,6 @@
  * processor options.
  */
 public class MvcContext {
-  private record ResultType(String type, String handler, boolean nonBlocking) {}
-
   private final ProcessingEnvironment processingEnvironment;
   private final boolean debug;
   private final boolean incremental;
@@ -34,7 +30,7 @@ private record ResultType(String type, String handler, boolean nonBlocking) {}
   private final BiConsumer<Diagnostic.Kind, String> output;
   private final List<MvcRouter> routers = new ArrayList<>();
   private final boolean mvcMethod;
-  private final Map<TypeElement, ResultType> handler = new HashMap<>();
+  private final Map<TypeElement, ReactiveType> reactiveTypeMap = new HashMap<>();
 
   public MvcContext(
       ProcessingEnvironment processingEnvironment, BiConsumer<Diagnostic.Kind, String> output) {
@@ -45,99 +41,28 @@ public MvcContext(
     this.mvcMethod = Options.boolOpt(processingEnvironment, Options.MVC_METHOD, false);
     this.routerPrefix = Options.string(processingEnvironment, Options.ROUTER_PREFIX, "");
     this.routerSuffix = Options.string(processingEnvironment, Options.ROUTER_SUFFIX, "_");
-    computeResultTypes(processingEnvironment, handler::put);
+    computeReactiveTypes(processingEnvironment, reactiveTypeMap::put);
 
     debug("Incremental annotation processing is turned %s.", incremental ? "ON" : "OFF");
   }
 
-  private void computeResultTypes(
-      ProcessingEnvironment processingEnvironment, BiConsumer<TypeElement, ResultType> consumer) {
-    var handler =
-        new HashSet<>(
-            Set.of(
-                "io.jooby.ReactiveSupport",
-                "io.jooby.mutiny.Mutiny",
-                "io.jooby.reactor.Reactor",
-                "io.jooby.rxjava3.Reactivex"));
-    handler.addAll(Options.stringListOpt(processingEnvironment, Options.HANDLER));
-    handler.stream()
-        .map(type -> processingEnvironment.getElementUtils().getTypeElement(type))
-        .filter(Objects::nonNull)
+  private void computeReactiveTypes(
+      ProcessingEnvironment processingEnvironment, BiConsumer<TypeElement, ReactiveType> consumer) {
+    ReactiveType.supportedTypes()
         .forEach(
-            it -> {
-              var annotation =
-                  AnnotationSupport.findAnnotationByName(it, "io.jooby.annotation.ResultType");
-              if (annotation != null) {
-                var handlerFunction =
-                    AnnotationSupport.findAnnotationValue(annotation, "handler"::equals).get(0);
-                boolean nonBlocking =
-                    AnnotationSupport.findAnnotationValue(annotation, "nonBlocking"::equals)
-                        .stream()
-                        .findFirst()
-                        .map(Boolean::valueOf)
-                        .orElse(Boolean.FALSE);
-                ResultType entry;
-                var i = handlerFunction.lastIndexOf('.');
-                if (i > 0) {
-                  var container = handlerFunction.substring(0, i);
-                  var fn = handlerFunction.substring(i + 1);
-                  entry = new ResultType(container, fn, nonBlocking);
-                } else {
-                  entry = new ResultType(it.asType().toString(), handlerFunction, nonBlocking);
-                }
-                var functions =
-                    it.getEnclosedElements().stream()
-                        .filter(ExecutableElement.class::isInstance)
-                        .map(ExecutableElement.class::cast)
-                        .filter(m -> entry.handler.equals(m.getSimpleName().toString()))
-                        .toList();
-                if (functions.isEmpty()) {
-                  throw new IllegalArgumentException(
-                      "Method not found: " + entry.type + "." + entry.handler);
-                } else {
-                  var args =
-                      functions.stream()
-                          .filter(
-                              m ->
-                                  !m.getParameters().isEmpty()
-                                      && m.getParameters()
-                                          .get(0)
-                                          .asType()
-                                          .toString()
-                                          .equals("io.jooby.Route.Handler"))
-                          .findFirst()
-                          .orElseThrow(
-                              () ->
-                                  new IllegalArgumentException(
-                                      "Signature doesn't match: "
-                                          + functions
-                                          + " must be: "
-                                          + functions.stream()
-                                              .map(
-                                                  e ->
-                                                      e.getSimpleName()
-                                                          + "(io.jooby.Route.Handler)")
-                                              .collect(Collectors.joining(", ", "[", "]"))));
-                  if (!args.getReturnType().toString().equals("io.jooby.Route.Handler")) {
-                    throw new IllegalArgumentException(
-                        "Method returns type not supported: "
-                            + args
-                            + ": "
-                            + args.getReturnType()
-                            + " must be: "
-                            + args
-                            + ": io.jooby.Route.Handler");
-                  }
-                  if (!args.getModifiers().contains(Modifier.STATIC)) {
-                    throw new IllegalArgumentException("Method must be static: " + args);
-                  }
-                }
-                var types =
-                    AnnotationSupport.findAnnotationValue(
-                        annotation, "types"::equals, value -> (DeclaredType) value.getValue());
-                for (var type : types) {
-                  superTypes(type.asElement()).forEach(t -> consumer.accept(t, entry));
-                }
+            reactiveType -> {
+              var handlerType =
+                  processingEnvironment
+                      .getElementUtils()
+                      .getTypeElement(reactiveType.handlerType());
+              if (handlerType != null) {
+                // Handler Type is on classpath
+                reactiveType.reactiveTypes().stream()
+                    .map(it -> processingEnvironment.getElementUtils().getTypeElement(it))
+                    .forEach(
+                        it -> {
+                          superTypes(it).forEach(t -> consumer.accept(t, reactiveType));
+                        });
               }
             });
   }
@@ -199,11 +124,11 @@ public String pipeline(TypeMirror returnType, String handlerReference) {
 
   public boolean nonBlocking(TypeMirror returnType) {
     var entry = findMappingHandler(returnType);
-    return entry != null && entry.nonBlocking;
+    return entry != null;
   }
 
-  private ResultType findMappingHandler(TypeMirror type) {
-    for (var e : handler.entrySet()) {
+  private ReactiveType findMappingHandler(TypeMirror type) {
+    for (var e : reactiveTypeMap.entrySet()) {
       var that = e.getKey();
       if (type.toString().equals(that.toString())
           || processingEnvironment.getTypeUtils().isAssignable(type, that.asType())) {
@@ -281,7 +206,7 @@ public void generateStaticImports(MvcRouter mvcRouter, BiConsumer<String, String
       if (process.add(returnType.toString())) {
         var fnq = findMappingHandler(returnType);
         if (fnq != null) {
-          consumer.accept(fnq.type, fnq.handler);
+          consumer.accept(fnq.handlerType(), fnq.handler());
         }
       }
     }

modules/jooby-apt/src/main/java/io/jooby/internal/apt/MvcContext.java

@@ -0,0 +1,59 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.apt;
+
+import java.util.List;
+import java.util.Set;
+
+public class ReactiveType {
+
+  private final String handlerType;
+  private final String handler;
+  private final Set<String> reactiveTypes;
+
+  private ReactiveType(String handlerType, String handler, Set<String> reactiveTypes) {
+    this.handlerType = handlerType;
+    this.handler = handler;
+    this.reactiveTypes = reactiveTypes;
+  }
+
+  public Set<String> reactiveTypes() {
+    return reactiveTypes;
+  }
+
+  public String handlerType() {
+    return handlerType;
+  }
+
+  public String handler() {
+    return handler;
+  }
+
+  public static List<ReactiveType> supportedTypes() {
+    return List.of(
+        new ReactiveType(
+            "io.jooby.ReactiveSupport",
+            "concurrent",
+            Set.of("java.util.concurrent.Flow", "java.util.concurrent.CompletionStage")),
+        new ReactiveType(
+            "io.jooby.mutiny.Mutiny",
+            "mutiny",
+            Set.of("io.smallrye.mutiny.Uni", "io.smallrye.mutiny.Multi")),
+        new ReactiveType(
+            "io.jooby.reactor.Reactor",
+            "reactor",
+            Set.of("reactor.core.publisher.Flux", "reactor.core.publisher.Mono")),
+        new ReactiveType(
+            "io.jooby.rxjava3.Reactivex",
+            "rx",
+            Set.of(
+                "io.reactivex.rxjava3.core.Flowable",
+                "io.reactivex.rxjava3.core.Maybe",
+                "io.reactivex.rxjava3.core.Observable",
+                "io.reactivex.rxjava3.core.Single",
+                "io.reactivex.rxjava3.disposables.Disposable")));
+  }
+}