Upgrade JUEL to Jakarta Expression Language 6 and implement support for Lambda Expressions

* Add support for getting length of arrays
* Add OptionalELResolver
* Add RecordELResolver

Author: filiphr

modules/flowable-cdi/src/main/java/org/flowable/cdi/impl/el/CdiResolver.java

@@ -12,9 +12,6 @@
  */
 package org.flowable.cdi.impl.el;
 
-import java.beans.FeatureDescriptor;
-import java.util.Iterator;
-
 import jakarta.el.FunctionMapper;
 import jakarta.el.VariableMapper;
 import jakarta.enterprise.inject.spi.BeanManager;
@@ -81,11 +78,6 @@ public Class<?> getCommonPropertyType(ELContext context, Object base) {
         return getWrappedResolver().getCommonPropertyType(this.context, base);
     }
 
-    @Override
-    public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext context, Object base) {
-        return null;
-    }
-
     @Override
     public Class<?> getType(ELContext context, Object base, Object property) {
         return getWrappedResolver().getType(this.context, base, property);

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/ExpressionFactoryImpl.java

@@ -434,7 +434,7 @@ private Class<?> load(Class<?> clazz, Properties properties) {
 	}
 
 	@Override
-	public final Object coerceToType(Object obj, Class<?> targetType) {
+	public final <T> T coerceToType(Object obj, Class<T> targetType) {
 		return converter.convert(obj, targetType);
 	}
 

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/TreeMethodExpression.java

@@ -144,7 +144,7 @@ public boolean isLiteralText() {
 	 * @return <code>true</code> if this is a method invocation expression
 	 */
 	@Override
-	public boolean isParmetersProvided() {
+	public boolean isParametersProvided() {
 		return node.isMethodInvocation();
 	}
 

modules/flowable-engine-common/src/main/java/org/flowable/common/engine/impl/de/odysseus/el/misc/TypeConverterImpl.java

@@ -17,10 +17,15 @@
 
 import java.beans.PropertyEditor;
 import java.beans.PropertyEditorManager;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.util.function.Supplier;
 
 import org.flowable.common.engine.impl.javax.el.ELException;
+import org.flowable.common.engine.impl.javax.el.LambdaExpression;
 
 /**
  * Type Conversions as described in EL 2.1 specification (section 1.17).
@@ -303,12 +308,48 @@ protected Object coerceStringToType(String value, Class<?> type) {
 		}
 	}
 
+	protected <T> T coerceToFunctionalInterface(LambdaExpression lambdaExpression, Class<T> type) {
+		Supplier<T> proxy = () -> {
+			// Create a dynamic proxy for the functional interface
+			@SuppressWarnings("unchecked")
+			T result = (T) Proxy.newProxyInstance(type.getClassLoader(), new Class[] { type },
+					(Object obj, Method method, Object[] args) -> {
+						// Functional interfaces have a single, abstract method
+						if (!Modifier.isAbstract(method.getModifiers())) {
+							throw new ELException(LocalMessages.get("error.coerce.nonAbstract", type, method));
+						}
+						return lambdaExpression.invoke(args);
+					});
+			return result;
+		};
+		return proxy.get();
+	}
+
 	@SuppressWarnings("unchecked")
 	protected Object coerceToType(Object value, Class<?> type) {
-		if (type == null || Object.class.equals(type)) {
+		if (type == null) {
 			return value;
 		}
 
+		if (value instanceof LambdaExpression lambdaExpression) {
+			if (LambdaExpression.class == type) {
+				return lambdaExpression;
+			}
+			if (isFunctionalInterface(type)) {
+				return coerceToFunctionalInterface(lambdaExpression, (Class<?>) type);
+			}
+
+			if (lambdaExpression.getFormalParameters().isEmpty()) {
+				// If the value is a LambdaExpression without formal parameters we need to resolve its value
+				value = coerceToType(lambdaExpression.invoke(), type);
+			}
+		}
+
+		if (Object.class.equals(type)) {
+			return value;
+		}
+
+
 		if (type == String.class) {
 			return coerceToString(value);
 		}
@@ -372,4 +413,53 @@ public int hashCode() {
 	public <T> T convert(Object value, Class<T> type) throws ELException {
 		return (T)coerceToType(value, type);
 	}
+
+	// Copied from Tomcat org.apache.el.lang.ELSupport
+	static boolean isFunctionalInterface(Class<?> type) {
+
+		if (!type.isInterface()) {
+			return false;
+		}
+
+		boolean foundAbstractMethod = false;
+		Method[] methods = type.getMethods();
+		for (Method method : methods) {
+			if (Modifier.isAbstract(method.getModifiers())) {
+				// Abstract methods that override one of the public methods
+				// of Object don't count
+				if (overridesObjectMethod(method)) {
+					continue;
+				}
+				if (foundAbstractMethod) {
+					// Found more than one
+					return false;
+				} else {
+					foundAbstractMethod = true;
+				}
+			}
+		}
+		return foundAbstractMethod;
+	}
+
+	// Copied from Tomcat org.apache.el.lang.ELSupport
+	private static boolean overridesObjectMethod(Method method) {
+		// There are three methods that can be overridden
+		if ("equals".equals(method.getName())) {
+			if (method.getReturnType().equals(boolean.class)) {
+				if (method.getParameterCount() == 1) {
+					return method.getParameterTypes()[0].equals(Object.class);
+				}
+			}
+		} else if ("hashCode".equals(method.getName())) {
+			if (method.getReturnType().equals(int.class)) {
+				return method.getParameterCount() == 0;
+			}
+		} else if ("toString".equals(method.getName())) {
+			if (method.getReturnType().equals(String.class)) {
+				return method.getParameterCount() == 0;
+			}
+		}
+
+		return false;
+	}
 }