Feat: Enhance Kotlin arity handling in function context

This commit refactors the `spring-cloud-function-context` to comprehensively handle all combinations of possible declarations for Kotlin functions, consumers, and suppliers. This improves the framework's ability to correctly interpret and manage different Kotlin functional styles.

Signed-off-by: Adrien Poupard <adrien@komune.io>

Author: Adrien

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionRegistration.java

@@ -31,7 +31,7 @@
 
 import org.springframework.beans.factory.BeanNameAware;
 import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
-import org.springframework.cloud.function.context.config.KotlinLambdaToFunctionAutoConfiguration;
+import org.springframework.cloud.function.context.wrapper.KotlinFunctionWrapper;
 import org.springframework.core.KotlinDetector;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
@@ -118,7 +118,7 @@ public FunctionRegistration<T> properties(Map<String, String> properties) {
 
 	public FunctionRegistration<T> type(Type type) {
 		this.type = type;
-		if (KotlinDetector.isKotlinPresent() && this.target instanceof KotlinLambdaToFunctionAutoConfiguration.KotlinFunctionWrapper) {
+		if (KotlinDetector.isKotlinPresent() && this.target instanceof KotlinFunctionWrapper) {
 			return this;
 		}
 		Type discoveredFunctionType = type; //FunctionTypeUtils.discoverFunctionTypeFromClass(this.target.getClass());
@@ -174,15 +174,6 @@ public FunctionRegistration<T> names(String... names) {
 		return this.names(Arrays.asList(names));
 	}
 
-	/**
-	 * Transforms (wraps) function identified by the 'target' to its {@code Flux}
-	 * equivalent unless it already is. For example, {@code Function<String, String>}
-	 * becomes {@code Function<Flux<String>, Flux<String>>}
-	 * @param <S> the expected target type of the function (e.g., FluxFunction)
-	 * @return {@code FunctionRegistration} with the appropriately wrapped target.
-	 *
-	 */
-
 	@Override
 	public void setBeanName(String name) {
 		if (CollectionUtils.isEmpty(this.names)) {

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/BeanFactoryAwareFunctionRegistry.java

@@ -36,11 +36,12 @@
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.cloud.function.context.FunctionProperties;
 import org.springframework.cloud.function.context.FunctionRegistration;
 import org.springframework.cloud.function.context.FunctionRegistry;
 import org.springframework.cloud.function.context.config.FunctionContextUtils;
-import org.springframework.cloud.function.context.config.KotlinLambdaToFunctionAutoConfiguration;
+import org.springframework.cloud.function.context.config.KotlinLambdaToFunctionFactory;
 import org.springframework.cloud.function.context.config.RoutingFunction;
 import org.springframework.cloud.function.core.FunctionInvocationHelper;
 import org.springframework.cloud.function.json.JsonMapper;
@@ -120,7 +121,8 @@ public <T> T lookup(Class<?> type, String functionDefinition, String... expected
 		functionDefinition = StringUtils.hasText(functionDefinition)
 				? functionDefinition
 						: this.applicationContext.getEnvironment().getProperty(FunctionProperties.FUNCTION_DEFINITION, "");
-		if (!this.applicationContext.containsBean(functionDefinition) || !KotlinUtils.isKotlinType(this.applicationContext.getBean(functionDefinition))) {
+
+		if (!this.applicationContext.containsBean(functionDefinition) || !isKotlinType(functionDefinition)) {
 			functionDefinition = this.normalizeFunctionDefinition(functionDefinition);
 		}
 		if (!isFunctionDefinitionEligible(functionDefinition)) {
@@ -160,12 +162,9 @@ public <T> T lookup(Class<?> type, String functionDefinition, String... expected
 							else if (functionCandidate instanceof BiFunction || functionCandidate instanceof BiConsumer) {
 								functionRegistration = this.registerMessagingBiFunction(functionCandidate, functionName);
 							}
-							else if (KotlinUtils.isKotlinType(functionCandidate)) {
-								KotlinLambdaToFunctionAutoConfiguration.KotlinFunctionWrapper wrapper =
-									new KotlinLambdaToFunctionAutoConfiguration.KotlinFunctionWrapper(functionCandidate);
-								wrapper.setName(functionName);
-								wrapper.setBeanFactory(this.applicationContext.getBeanFactory());
-								functionRegistration = wrapper.getFunctionRegistration();
+							else if (isKotlinType(functionName, functionCandidate)) {
+								KotlinLambdaToFunctionFactory kotlinFactory = new KotlinLambdaToFunctionFactory(functionCandidate, this.applicationContext.getBeanFactory());
+								functionRegistration = kotlinFactory.getFunctionRegistration(functionName);
 							}
 							else if (this.isFunctionPojo(functionCandidate, functionName)) {
 								Method functionalMethod = FunctionTypeUtils.discoverFunctionalMethod(functionCandidate.getClass());
@@ -203,6 +202,17 @@ else if (this.isSpecialFunctionRegistration(functionNames, functionName)) {
 		return (T) function;
 	}
 
+	private boolean isKotlinType(String functionDefinition) {
+		Object fonctionBean = this.applicationContext.getBean(functionDefinition);
+		return isKotlinType(functionDefinition, fonctionBean);
+	}
+
+	private boolean isKotlinType(String functionDefinition, Object fonctionBean) {
+		ConfigurableListableBeanFactory beanFactory = this.applicationContext.getBeanFactory();
+		Type functionType = FunctionContextUtils.findType(functionDefinition, beanFactory);
+		return KotlinUtils.isKotlinType(fonctionBean, functionType);
+	}
+
 	@SuppressWarnings({ "rawtypes", "unchecked" })
 	private FunctionRegistration registerMessagingBiFunction(Object userFunction, String functionName) {
 		Type biFunctionType = FunctionContextUtils.findType(this.applicationContext.getBeanFactory(), functionName);

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/FunctionTypeUtils.java

@@ -48,6 +48,7 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.reactivestreams.Publisher;
@@ -234,6 +235,10 @@ else if (Function0.class.isAssignableFrom(functionalClass)) {
 				ResolvableType kotlinType = ResolvableType.forClass(functionalClass).as(Function0.class);
 				return GenericTypeResolver.resolveType(kotlinType.getType(), functionalClass);
 			}
+			else if (Function2.class.isAssignableFrom(functionalClass)) {
+				ResolvableType kotlinType = ResolvableType.forClass(functionalClass).as(Function2.class);
+				return GenericTypeResolver.resolveType(kotlinType.getType(), functionalClass);
+			}
 		}
 		Type typeToReturn = null;
 		if (Function.class.isAssignableFrom(functionalClass)) {