Support Kotlin parameter default values in handler methods

This commit adds support for Kotlin parameter default values
in handler methods. It allows to write:
@RequestParam value: String = "default"
as an alternative to:
@RequestParam(defaultValue = "default") value: String

Both Spring MVC and WebFlux are supported, including on
suspending functions.

Closes gh-21139

Author: sdeleuze

spring-core/src/main/java/org/springframework/core/CoroutinesUtils.java

@@ -18,6 +18,7 @@
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.Map;
 import java.util.Objects;
 
 import kotlin.Unit;
@@ -26,6 +27,7 @@
 import kotlin.reflect.KClass;
 import kotlin.reflect.KClassifier;
 import kotlin.reflect.KFunction;
+import kotlin.reflect.KParameter;
 import kotlin.reflect.full.KCallables;
 import kotlin.reflect.jvm.KCallablesJvm;
 import kotlin.reflect.jvm.ReflectJvmMapping;
@@ -42,6 +44,7 @@
 import reactor.core.publisher.Mono;
 
 import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
 
 /**
  * Utilities for working with Kotlin Coroutines.
@@ -104,8 +107,22 @@ public static Publisher<?> invokeSuspendingFunction(CoroutineContext context, Me
 		if (method.isAccessible() && !KCallablesJvm.isAccessible(function)) {
 			KCallablesJvm.setAccessible(function, true);
 		}
-		Mono<Object> mono = MonoKt.mono(context, (scope, continuation) ->
-					KCallables.callSuspend(function, getSuspendedFunctionArgs(method, target, args), continuation))
+		Mono<Object> mono = MonoKt.mono(context, (scope, continuation) -> {
+					Map<KParameter, Object> argMap = CollectionUtils.newHashMap(args.length + 1);
+					int index = 0;
+					for (KParameter parameter : function.getParameters()) {
+						switch (parameter.getKind()) {
+							case INSTANCE -> argMap.put(parameter, target);
+							case VALUE -> {
+								if (!parameter.isOptional() || args[index] != null) {
+									argMap.put(parameter, args[index]);
+								}
+								index++;
+							}
+						}
+					}
+					return KCallables.callSuspendBy(function, argMap, continuation);
+				})
 				.filter(result -> !Objects.equals(result, Unit.INSTANCE))
 				.onErrorMap(InvocationTargetException.class, InvocationTargetException::getTargetException);
 
@@ -125,14 +142,6 @@ else if (returnType instanceof KClass<?> kClass &&
 		return mono;
 	}
 
-	private static Object[] getSuspendedFunctionArgs(Method method, Object target, Object... args) {
-		int length = (args.length == method.getParameterCount() - 1 ? args.length + 1 : args.length);
-		Object[] functionArgs = new Object[length];
-		functionArgs[0] = target;
-		System.arraycopy(args, 0, functionArgs, 1, length - 1);
-		return functionArgs;
-	}
-
 	private static Flux<?> asFlux(Object flow) {
 		return ReactorFlowKt.asFlux(((Flow<?>) flow));
 	}

spring-core/src/test/kotlin/org/springframework/core/KotlinMethodParameterTests.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,6 +38,8 @@ class KotlinMethodParameterTests {
 
 	private val nonNullableMethod = javaClass.getMethod("nonNullable", String::class.java)
 
+	private val withDefaultValueMethod: Method = javaClass.getMethod("withDefaultValue", String::class.java)
+
 	private val innerClassConstructor = InnerClass::class.java.getConstructor(KotlinMethodParameterTests::class.java)
 
 	private val innerClassWithParametersConstructor = InnerClassWithParameter::class.java
@@ -52,6 +54,16 @@ class KotlinMethodParameterTests {
 		assertThat(MethodParameter(nonNullableMethod, 0).isOptional).isFalse()
 	}
 
+	@Test
+	fun `Method parameter with default value`() {
+		assertThat(MethodParameter(withDefaultValueMethod, 0).isOptional).isTrue()
+	}
+
+	@Test
+	fun `Method parameter without default value`() {
+		assertThat(MethodParameter(nonNullableMethod, 0).isOptional).isFalse()
+	}
+
 	@Test
 	fun `Method return type nullability`() {
 		assertThat(MethodParameter(nullableMethod, -1).isOptional).isTrue()
@@ -123,6 +135,8 @@ class KotlinMethodParameterTests {
 	@Suppress("unused_parameter")
 	fun nonNullable(nonNullable: String): Int = 42
 
+	fun withDefaultValue(withDefaultValue: String = "default") = withDefaultValue
+
 	inner class InnerClass
 
 	@Suppress("unused_parameter")

spring-web/src/main/java/org/springframework/web/method/annotation/AbstractNamedValueMethodArgumentResolver.java

@@ -16,16 +16,22 @@
 
 package org.springframework.web.method.annotation;
 
+import java.lang.reflect.Method;
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 
 import jakarta.servlet.ServletException;
+import kotlin.reflect.KFunction;
+import kotlin.reflect.KParameter;
+import kotlin.reflect.jvm.ReflectJvmMapping;
 
 import org.springframework.beans.ConversionNotSupportedException;
 import org.springframework.beans.TypeMismatchException;
 import org.springframework.beans.factory.config.BeanExpressionContext;
 import org.springframework.beans.factory.config.BeanExpressionResolver;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.core.KotlinDetector;
 import org.springframework.core.MethodParameter;
 import org.springframework.lang.Nullable;
 import org.springframework.web.bind.ServletRequestBindingException;
@@ -60,6 +66,7 @@
  * @author Arjen Poutsma
  * @author Rossen Stoyanchev
  * @author Juergen Hoeller
+ * @author Sebastien Deleuze
  * @since 3.1
  */
 public abstract class AbstractNamedValueMethodArgumentResolver implements HandlerMethodArgumentResolver {
@@ -98,6 +105,9 @@ public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAn
 
 		NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
 		MethodParameter nestedParameter = parameter.nestedIfOptional();
+		boolean hasDefaultValue = KotlinDetector.isKotlinReflectPresent()
+				&& KotlinDetector.isKotlinType(parameter.getDeclaringClass())
+				&& KotlinDelegate.hasDefaultValue(nestedParameter);
 
 		Object resolvedName = resolveEmbeddedValuesAndExpressions(namedValueInfo.name);
 		if (resolvedName == null) {
@@ -113,13 +123,15 @@ public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAn
 			else if (namedValueInfo.required && !nestedParameter.isOptional()) {
 				handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
 			}
-			arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
+			if (!hasDefaultValue) {
+				arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
+			}
 		}
 		else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
 			arg = resolveEmbeddedValuesAndExpressions(namedValueInfo.defaultValue);
 		}
 
-		if (binderFactory != null) {
+		if (binderFactory != null && (arg != null || !hasDefaultValue)) {
 			WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
 			try {
 				arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
@@ -304,4 +316,27 @@ public NamedValueInfo(String name, boolean required, @Nullable String defaultVal
 		}
 	}
 
+	/**
+	 * Inner class to avoid a hard dependency on Kotlin at runtime.
+	 */
+	private static class KotlinDelegate {
+
+		/**
+		 * Check whether the specified {@link MethodParameter} represents a nullable Kotlin type
+		 * or an optional parameter (with a default value in the Kotlin declaration).
+		 */
+		public static boolean hasDefaultValue(MethodParameter parameter) {
+			Method method = Objects.requireNonNull(parameter.getMethod());
+			KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
+			if (function != null) {
+				int index = 0;
+				for (KParameter kParameter : function.getParameters()) {
+					if (KParameter.Kind.VALUE.equals(kParameter.getKind()) && parameter.getParameterIndex() == index++) {
+						return kParameter.isOptional();
+					}
+				}
+			}
+			return false;
+		}
+	}
 }

spring-web/src/main/java/org/springframework/web/method/support/InvocableHandlerMethod.java

@@ -19,7 +19,13 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
 
+import kotlin.reflect.KFunction;
+import kotlin.reflect.KParameter;
+import kotlin.reflect.jvm.KCallablesJvm;
+import kotlin.reflect.jvm.ReflectJvmMapping;
 import org.reactivestreams.Publisher;
 
 import org.springframework.context.MessageSource;
@@ -29,6 +35,7 @@
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ParameterNameDiscoverer;
 import org.springframework.lang.Nullable;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.ObjectUtils;
 import org.springframework.validation.beanvalidation.MethodValidator;
 import org.springframework.web.bind.WebDataBinder;
@@ -236,8 +243,13 @@ private Class<?>[] getValidationGroups() {
 	protected Object doInvoke(Object... args) throws Exception {
 		Method method = getBridgedMethod();
 		try {
-			if (KotlinDetector.isSuspendingFunction(method)) {
-				return invokeSuspendingFunction(method, getBean(), args);
+			if (KotlinDetector.isKotlinReflectPresent()) {
+				if (KotlinDetector.isSuspendingFunction(method)) {
+					return invokeSuspendingFunction(method, getBean(), args);
+				}
+				else if (KotlinDetector.isKotlinType(method.getDeclaringClass())) {
+					return KotlinDelegate.invokeFunction(method, getBean(), args);
+				}
 			}
 			return method.invoke(getBean(), args);
 		}
@@ -279,4 +291,33 @@ protected Publisher<?> invokeSuspendingFunction(Method method, Object target, Ob
 		return CoroutinesUtils.invokeSuspendingFunction(method, target, args);
 	}
 
+	/**
+	 * Inner class to avoid a hard dependency on Kotlin at runtime.
+	 */
+	private static class KotlinDelegate {
+
+		@Nullable
+		@SuppressWarnings("deprecation")
+		public static Object invokeFunction(Method method, Object target, Object[] args) {
+			KFunction<?> function = Objects.requireNonNull(ReflectJvmMapping.getKotlinFunction(method));
+			if (method.isAccessible() && !KCallablesJvm.isAccessible(function)) {
+				KCallablesJvm.setAccessible(function, true);
+			}
+			Map<KParameter, Object> argMap = CollectionUtils.newHashMap(args.length + 1);
+			int index = 0;
+			for (KParameter parameter : function.getParameters()) {
+				switch (parameter.getKind()) {
+					case INSTANCE -> argMap.put(parameter, target);
+					case VALUE -> {
+						if (!parameter.isOptional() || args[index] != null) {
+							argMap.put(parameter, args[index]);
+						}
+						index++;
+					}
+				}
+			}
+			return function.callBy(argMap);
+		}
+	}
+
 }

spring-web/src/test/java/org/springframework/web/method/support/StubArgumentResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -47,7 +47,7 @@ public StubArgumentResolver(Class<?> valueType) {
 		this(valueType, null);
 	}
 
-	public StubArgumentResolver(Class<?> valueType, Object value) {
+	public StubArgumentResolver(Class<?> valueType, @Nullable Object value) {
 		this.valueType = valueType;
 		this.value = value;
 	}