Fix lambda instantiated method signatures

Update `LambdaUtils` to accept an explicit functional input type when creating `Function`, `Consumer`, and generic lambdas so the generated instantiated method signature matches the target method parameters. Add tests covering multi-argument lambda creation and constant-pool inspection of generated lambda classes.

Author: mercyblitz

microsphere-java-core/src/main/java/io/microsphere/lang/invoke/LambdaUtils.java

@@ -31,6 +31,7 @@
 
 import static io.microsphere.invoke.MethodHandleUtils.findVirtual;
 import static io.microsphere.reflect.MethodUtils.findFunctionalInterfaceMethod;
+import static io.microsphere.util.ArrayUtils.combine;
 import static java.lang.invoke.LambdaMetafactory.metafactory;
 import static java.lang.invoke.MethodHandles.lookup;
 import static java.lang.invoke.MethodType.methodType;
@@ -49,30 +50,28 @@ public abstract class LambdaUtils implements Utils {
     /**
      * Creates a {@link Function} lambda instance for the specified target class, and method.
      *
-     * @param targetClass    the target class containing the method to be invoked
-     * @param methodName     the name of the method to be invoked
-     * @param parameterTypes the parameter types of the method to be invoked
-     * @param <T>            the type of the function input
-     * @param <R>            the return type of the function
+     * @param targetClass the target class containing the method to be invoked
+     * @param methodName  the name of the method to be invoked
+     * @param <T>         the type of the function input
+     * @param <R>         the return type of the function
      * @return a {@link Function} lambda instance
      * @throws Throwable if an error occurs during lambda creation
      */
-    public static <T, R> Function<T, R> function(Class<T> targetClass, String methodName, Class<?>... parameterTypes) throws Throwable {
-        return lambda(Function.class, targetClass, methodName, parameterTypes);
+    public static <T, R> Function<T, R> function(Class<T> functionInputType, Class<T> targetClass, String methodName) throws Throwable {
+        return lambda(Function.class, functionInputType, targetClass, methodName);
     }
 
     /**
      * Creates a {@link Consumer} lambda instance for the specified target class, and method.
      *
-     * @param targetClass    the target class containing the method to be invoked
-     * @param methodName     the name of the method to be invoked
-     * @param parameterTypes the parameter types of the method to be invoked
-     * @param <T>            the type of the consumer input
+     * @param targetClass the target class containing the method to be invoked
+     * @param methodName  the name of the method to be invoked
+     * @param <T>         the type of the consumer input
      * @return a {@link Consumer} lambda instance
      * @throws Throwable if an error occurs during lambda creation
      */
-    public static <T> Consumer<T> consumer(Class<T> targetClass, String methodName, Class<?>... parameterTypes) throws Throwable {
-        return lambda(Consumer.class, targetClass, methodName, parameterTypes);
+    public static <T> Consumer<T> consumer(Class<T> functionInputType, Class<T> targetClass, String methodName) throws Throwable {
+        return lambda(Consumer.class, functionInputType, targetClass, methodName);
     }
 
     /**
@@ -81,12 +80,13 @@ public static <T> Consumer<T> consumer(Class<T> targetClass, String methodName,
      * @param functionalInterface the functional interface class
      * @param targetClass         the target class containing the method to be invoked
      * @param methodName          the name of the method to be invoked
-     * @param parameterTypes      the parameter types of the method to be invoked
+     * @param parameterTypes      the types of the method parameters
      * @param <F>                 the type of the functional interface
      * @return a lambda instance implementing the specified functional interface
      * @throws Throwable if an error occurs during lambda creation
      */
-    public static <F> F lambda(Class<F> functionalInterface, Class<?> targetClass, String methodName, Class<?>... parameterTypes) throws Throwable {
+    public static <F> F lambda(Class<F> functionalInterface, Class<?> functionInputType,
+                               Class<?> targetClass, String methodName, Class<?>... parameterTypes) throws Throwable {
         // 1. Set up the target method lookup context
         Lookup lookup = lookup();
 
@@ -102,7 +102,8 @@ public static <F> F lambda(Class<F> functionalInterface, Class<?> targetClass, S
         MethodType samMethodType = methodType(functionalInterfaceReturnType, functionalInterfaceMethodParameterTypes);
 
         // The type signature of the functional interface's abstract method (instantiated type)
-        MethodType instantiatedMethodType = methodType(functionalInterfaceReturnType, targetClass);
+        Class<?>[] instantiatedMethodParameterTypes = combine(functionInputType, parameterTypes);
+        MethodType instantiatedMethodType = methodType(functionalInterfaceReturnType, instantiatedMethodParameterTypes);
 
         // 4. Invoke LambdaMetafactory to spin the runtime lambda class
         CallSite callSite = metafactory(

microsphere-java-core/src/test/java/io/microsphere/internal/reflect/ConstantPoolUtilsTest.java

@@ -18,10 +18,15 @@
 package io.microsphere.internal.reflect;
 
 
+import io.microsphere.event.EchoEvent;
+import io.microsphere.event.EventListener;
 import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
 import java.util.Set;
+import java.util.function.Function;
 
 import static io.microsphere.internal.reflect.ConstantPoolUtils.CONSTANT_POOL_CLASS;
 import static io.microsphere.internal.reflect.ConstantPoolUtils.getClassAt;
@@ -42,9 +47,11 @@
 import static io.microsphere.internal.reflect.ConstantPoolUtils.getSize;
 import static io.microsphere.internal.reflect.ConstantPoolUtils.getStringAt;
 import static io.microsphere.internal.reflect.ConstantPoolUtils.getUTF8At;
+import static io.microsphere.lang.invoke.LambdaUtils.function;
 import static io.microsphere.reflect.FieldUtils.findAllDeclaredFields;
 import static io.microsphere.reflect.FieldUtils.getStaticFieldValue;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -96,4 +103,44 @@ void testGetter() {
             assertDoesNotThrow(() -> getUTF8At(targetClass, index));
         }
     }
+
+    @Test
+    void testDeduceGenericTypeFromLambda() {
+        EventListener<EchoEvent> e = event -> {
+        };
+
+        Class<? extends EventListener> targetClass = e.getClass();
+
+        int count = 0;
+
+        int size = getSize(targetClass);
+        for (int i = 0; i < size; i++) {
+            Member member = getMethodAt(targetClass, i);
+            if (member instanceof Method) {
+                count++;
+            }
+        }
+
+        assertEquals(1, count);
+    }
+
+    @Test
+    void testDeduceGenericTypeFromLambda2() throws Throwable {
+        Function<String, String> toUpperCase = function(String.class, String.class, "toUpperCase");
+
+        Class<?> targetClass = toUpperCase.getClass();
+
+        int count = 0;
+
+        int size = getSize(targetClass);
+        for (int i = size - 1; i >= 0; i--) {
+            Member member = getMethodAt(targetClass, i);
+            if (member instanceof Method) {
+                count++;
+            }
+        }
+
+        assertEquals(1, count);
+    }
+
 }

microsphere-java-core/src/test/java/io/microsphere/lang/invoke/LambdaUtilsTest.java

@@ -20,12 +20,14 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
 import static io.microsphere.lang.invoke.LambdaUtils.consumer;
 import static io.microsphere.lang.invoke.LambdaUtils.function;
 import static io.microsphere.lang.invoke.LambdaUtils.lambda;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -40,22 +42,22 @@ public class LambdaUtilsTest {
 
     @Test
     void testFunction() throws Throwable {
-        Function<String, String> toUpperCase = function(String.class, "toUpperCase");
+        Function<String, String> toUpperCase = function(String.class, String.class, "toUpperCase");
         assertEquals("HELLO WORLD", toUpperCase.apply("hello world"));
 
-        Function<String, Integer> lengthFunction = function(String.class, "length");
+        Function<String, Integer> lengthFunction = function(String.class, String.class, "length");
         assertEquals(11, lengthFunction.apply("hello world"));
     }
 
     @Test
     void testConsumer() throws Throwable {
-        Consumer<String> consumer = consumer(String.class, "toString");
+        Consumer<String> consumer = consumer(String.class, String.class, "toString");
         assertDoesNotThrow(() -> consumer.accept("hello world"));
     }
 
     @Test
     void testLambda() throws Throwable {
-        Function<String, String> toUpperCase = lambda(Function.class, String.class, "toUpperCase");
-        assertEquals("HELLO WORLD", toUpperCase.apply("hello world"));
+        BiFunction<String, String, byte[]> getBytes = lambda(BiFunction.class, String.class, String.class, "getBytes", String.class);
+        assertArrayEquals("hello world".getBytes("UTF-8"), getBytes.apply("hello world", "UTF-8"));
     }
 }