Qute generator: fix multiple namespace extension methods

- fixes quarkusio#50618

Co-authored-by: George Gastaldi <[email protected]>

Author: mkouba

extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/QuteProcessor.java

@@ -145,7 +145,7 @@
 import io.quarkus.qute.deployment.TypeInfos.TypeInfo;
 import io.quarkus.qute.deployment.Types.AssignabilityCheck;
 import io.quarkus.qute.generator.ExtensionMethodGenerator;
-import io.quarkus.qute.generator.ExtensionMethodGenerator.ExtensionMethodInfo;
+import io.quarkus.qute.generator.ExtensionMethodGenerator.NamespaceExtensionMethodInfo;
 import io.quarkus.qute.generator.ExtensionMethodGenerator.Param;
 import io.quarkus.qute.generator.TemplateGlobalGenerator;
 import io.quarkus.qute.generator.ValueResolverGenerator;
@@ -2107,12 +2107,13 @@ public Function<FieldInfo, String> apply(ClassInfo clazz) {
                         .collect(Collectors.groupingBy(TemplateExtensionMethodBuildItem::getPriority));
 
                 for (Entry<Integer, List<TemplateExtensionMethodBuildItem>> priorityEntry : priorityToMethods.entrySet()) {
-                    List<ExtensionMethodGenerator.ExtensionMethodInfo> extensionMethods = new ArrayList<>(
+                    List<ExtensionMethodGenerator.NamespaceExtensionMethodInfo> extensionMethods = new ArrayList<>(
                             priorityEntry.getValue().size());
                     for (TemplateExtensionMethodBuildItem method : priorityEntry.getValue()) {
                         extensionMethods
-                                .add(new ExtensionMethodInfo(method.getMethod(), method.getMatchName(), method.getMatchNames(),
-                                        method.getMatchRegex()));
+                                .add(new NamespaceExtensionMethodInfo(method.getMethod(), method.getMatchName(),
+                                        Set.copyOf(method.getMatchNames()),
+                                        method.getMatchRegex(), method.getParams()));
                     }
                     String generatedType = extensionMethodGenerator.generateNamespaceResolver(
                             priorityEntry.getValue().get(0).getMethod().declaringClass(), nsEntry.getKey(),

independent-projects/qute/core/src/main/java/io/quarkus/qute/EvaluatedParams.java

@@ -141,18 +141,18 @@ public Object getResult(int index) throws InterruptedException, ExecutionExcepti
      */
     public boolean parameterTypesMatch(boolean varargs, Class<?>[] types) throws InterruptedException, ExecutionException {
         // Check the number of parameters and replace the last param type with component type if needed
+        Class<?> componentType = null;
         if (types.length == results.length) {
             if (varargs) {
-                types[types.length - 1] = types[types.length - 1].getComponentType();
+                componentType = boxType(types[types.length - 1].getComponentType());
             }
         } else {
             if (varargs) {
                 int diff = types.length - results.length;
                 if (diff > 1) {
                     return false;
                 } else if (diff < 1) {
-                    Class<?> varargsType = types[types.length - 1];
-                    types[types.length - 1] = varargsType.getComponentType();
+                    componentType = boxType(types[types.length - 1].getComponentType());
                 }
                 // if diff == 1 then vargs may be empty and we need to compare the result types
             } else {
@@ -165,7 +165,11 @@ public boolean parameterTypesMatch(boolean varargs, Class<?>[] types) throws Int
             Object result = getResult(i);
             if (result != null) {
                 Class<?> resultClass = boxType(result.getClass());
-                if (!paramType.isAssignableFrom(resultClass)) {
+                if (!paramType.isAssignableFrom(resultClass)
+                        // For varargs we also try to match the component type
+                        && (componentType == null
+                                || i < (types.length - 1)
+                                || !componentType.isAssignableFrom(resultClass))) {
                     return false;
                 }
             }
@@ -178,14 +182,30 @@ public boolean parameterTypesMatch(boolean varargs, Class<?>[] types) throws Int
 
     public Object getVarargsResults(int numberOfParameters, Class<?> componentType)
             throws InterruptedException, ExecutionException {
+        // For varargs we want to skip all previous args
         int skip = numberOfParameters - 1;
-        if (skip < 0) {
+        if (skip < 0 || skip >= results.length) {
             return Array.newInstance(componentType, 0);
         }
+        Object result = null;
+        int capacity = results.length - skip;
+        if (numberOfParameters == results.length) {
+            // If there is exactly one non-skipped argument
+            // test if it's not a matching array
+            result = getResult(skip);
+            Class<?> resultClass = result.getClass();
+            if (resultClass.isArray() && resultClass.getComponentType().equals(componentType)) {
+                return result;
+            }
+            skip++;
+        }
+        Object array = Array.newInstance(componentType, capacity);
         int idx = 0;
-        Object array = Array.newInstance(componentType, results.length - skip);
+        if (result != null) {
+            Array.set(array, idx++, result);
+        }
         for (int i = skip; i < results.length; i++) {
-            Object result = getResult(i);
+            result = getResult(i);
             Array.set(array, idx++, result);
         }
         return array;

independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateExtension.java

@@ -138,11 +138,13 @@
     int priority() default DEFAULT_PRIORITY;
 
     /**
-     * If not empty a namespace resolver is generated instead.
+     * If not empty then a namespace resolver is generated.
      * <p>
-     * Template extension methods that share the same namespace and are declared on the same class are grouped in one resolver
-     * and ordered by {@link #priority()}. The first matching extension method is used to resolve an expression. Template
-     * extension methods declared on different classes cannot share the same namespace.
+     * Multiple extension methods declared on the same class can share the same namespace. However, extension methods declared
+     * on different classes cannot share the same namespace.
+     * <p>
+     * It's recommended to specify the {@link #priority()} if multiple extension methods that share the same namespace also
+     * match the same property/method name and parameters.
      *
      * @return the namespace
      * @see NamespaceResolver#getNamespace()