Issue #11: Support of static functions with varargs

Validating vararg-functions allow dynamic parameter count and
invoking vararg-functions uses the existing parameter-resolution
which already supports varargs.

Author: mhohndorf

src/main/java/org/glassfish/expressly/Messages.properties

@@ -51,6 +51,7 @@ error.property.notfound=Property ''{1}'' not found on {0}
 error.fnMapper.null=Expression uses functions, but no FunctionMapper was provided
 error.fnMapper.method=Function ''{0}'' not found
 error.fnMapper.paramcount=Function ''{0}'' specifies {1} params, but {2} were supplied
+error.fnMapper.minparamcount=Function ''{0}'' requires at least {1} params, but {2} were supplied
 
 # **ExpressionImpl
 error.context.null=ELContext was null

src/main/java/org/glassfish/expressly/lang/ExpressionBuilder.java

@@ -240,7 +240,12 @@ public void visit(Node node) throws ELException {
 
             int parameterCount = functionMethod.getParameterCount();
             int argumentCount = ((AstMethodArguments) node.jjtGetChild(0)).getParameterCount();
-            if (argumentCount != parameterCount) {
+            if(functionMethod.isVarArgs()) {
+                // last param of the method is the vararg -> 0..n vararg-arguments allowed
+                if (argumentCount < parameterCount - 1) {
+                    throw new ELException(MessageFactory.get("error.fnMapper.minparamcount", funcNode.getOutputName(), parameterCount - 1, argumentCount));
+                }
+            } else if (argumentCount != parameterCount) {
                 throw new ELException(MessageFactory.get("error.fnMapper.paramcount", funcNode.getOutputName(), parameterCount, argumentCount));
             }
         } else if (node instanceof AstIdentifier && varMapper != null) {

src/main/java/org/glassfish/expressly/parser/AstFunction.java

@@ -22,6 +22,7 @@
 
 import org.glassfish.expressly.lang.EvaluationContext;
 import org.glassfish.expressly.util.MessageFactory;
+import org.glassfish.expressly.util.ReflectionUtil;
 
 import jakarta.el.ELClass;
 import jakarta.el.ELException;
@@ -167,12 +168,11 @@ public Object getValue(EvaluationContext ctx) throws ELException {
         Class<?>[] paramTypes = functionMethod.getParameterTypes();
         Object[] params = ((AstMethodArguments) this.children[0]).getParameters(ctx);
         Object result = null;
-        for (int i = 0; i < params.length; i++) {
-            try {
-                params[i] = ctx.convertToType(params[i], paramTypes[i]);
-            } catch (ELException ele) {
-                throw new ELException(MessageFactory.get("error.function", this.getOutputName()), ele);
-            }
+        try {
+            params = ReflectionUtil.buildParameters(ctx, paramTypes, functionMethod.isVarArgs(), params);
+        }
+        catch(ELException ele) {
+            throw new ELException(MessageFactory.get("error.function", this.getOutputName()), ele);
         }
 
         try {

src/test/java/org/glassfish/el/test/ELProcessorTest.java

@@ -26,10 +26,12 @@
 
 import jakarta.el.ELProcessor;
 import jakarta.el.ELManager;
+import jakarta.el.ELException;
 import jakarta.el.ExpressionFactory;
 import jakarta.el.MethodExpression;
 import jakarta.el.ELContext;
 import java.lang.reflect.Method;
+import java.util.Arrays;
 
 public class ELProcessorTest {
 
@@ -160,6 +162,55 @@ public void defineFuncTest() {
         }
         assertTrue(caught);
     }
+
+    @Test
+    public void defineVarargFuncTest()
+    {
+        Class<?> c = MyBean.class;
+        Method meth = null;
+        Method meth2 = null;
+        try {
+            meth = c.getMethod("getSum", new Class<?>[] {int[].class});
+            meth2 = c.getMethod("getSumOffset", new Class<?>[] {int.class, int[].class});
+        } catch(Exception e) {
+            System.out.printf("Exception: ", e);
+        }
+        try {
+            elp.defineFunction("xx", "", meth);
+            Integer sum = elp.eval("xx:getSum()");
+            assertEquals(0, sum.intValue());
+            sum = elp.eval("xx:getSum(10)");
+            assertEquals(10, sum.intValue());
+            sum = elp.eval("xx:getSum(10, 20)");
+            assertEquals(30, sum.intValue());
+        } catch(NoSuchMethodException ex) {
+
+        }
+
+        boolean caught = false;
+        try {
+            elp.defineFunction("xx", "", meth2);
+            Integer sum = elp.eval("xx:getSumOffset()");
+            assertEquals(0, sum.intValue());
+        } catch (ELException ex) {
+            caught = true;
+        } catch (NoSuchMethodException ex) {
+
+        }
+        assertTrue(caught);
+
+        try {
+            elp.defineFunction("xx", "", meth2);
+            Integer sum = elp.eval("xx:getSumOffset(10)");
+            assertEquals(10, sum.intValue());
+            sum = elp.eval("xx:getSumOffset(10, 20)");
+            assertEquals(30, sum.intValue());
+            sum = elp.eval("xx:getSumOffset(10, 20, 30)");
+            assertEquals(60, sum.intValue());
+        } catch(NoSuchMethodException ex) {
+
+        }
+    }
 /*
     @Test
     public void testBean() {
@@ -200,6 +251,12 @@ public int getFoo(int i) {
         public static int getBar() {
             return 64;
         }
+        public static int getSum(int... args) {
+            return Arrays.stream(args).sum();
+        }
+        public static int getSumOffset(int offset, int... args) {
+            return offset + getSum(args);
+        }
     }
 }