Support Kotlin value classes in binder

This commit adds support for Kotlin Value classes when binding arguments
to `@SchemaMapping` methods.
Complete Framework support is not available yet, but this change unlocks
typical Kotlin usage in GraphQL applications.

Closes gh-1186

Author: bclozel

spring-graphql/src/main/java/org/springframework/graphql/data/GraphQlArgumentBinder.java

@@ -25,6 +25,14 @@
 import java.util.Optional;
 
 import graphql.schema.DataFetchingEnvironment;
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.reflect.KClass;
+import kotlin.reflect.KFunction;
+import kotlin.reflect.KParameter;
+import kotlin.reflect.KType;
+import kotlin.reflect.full.KClasses;
+import kotlin.reflect.jvm.KCallablesJvm;
+import kotlin.reflect.jvm.ReflectJvmMapping;
 
 import org.springframework.beans.BeanInstantiationException;
 import org.springframework.beans.BeanUtils;
@@ -36,6 +44,7 @@
 import org.springframework.beans.TypeMismatchException;
 import org.springframework.core.CollectionFactory;
 import org.springframework.core.Conventions;
+import org.springframework.core.KotlinDetector;
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.ConversionService;
@@ -280,7 +289,7 @@ private Object bindViaConstructorAndSetters(Constructor<?> constructor,
 		Map<String, Object> dataToBind = new HashMap<>(rawMap);
 		String[] paramNames = BeanUtils.getParameterNames(constructor);
 		Class<?>[] paramTypes = constructor.getParameterTypes();
-		Object[] constructorArguments = new Object[paramTypes.length];
+		Object[] constructorArguments = new Object[paramNames.length];
 
 		for (int i = 0; i < paramNames.length; i++) {
 			String name = paramNames[i];
@@ -290,8 +299,12 @@ private Object bindViaConstructorAndSetters(Constructor<?> constructor,
 
 			constructorArguments[i] = bindRawValue(
 					name, dataToBind.get(name), !dataToBind.containsKey(name), targetType, paramTypes[i], bindingResult);
+
 			dataToBind.remove(name);
 		}
+		if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(constructor.getDeclaringClass())) {
+			KotlinDelegate.rebindKotlinArguments(constructorArguments, constructor);
+		}
 
 		Object target;
 		try {
@@ -419,4 +432,37 @@ void rejectArgumentValue(
 		}
 	}
 
+	// remove in favor of https://github.com/spring-projects/spring-framework/issues/33630
+	private static final class KotlinDelegate {
+
+		public static void rebindKotlinArguments(Object[] arguments, Constructor<?> constructor) {
+			KFunction<?> function = ReflectJvmMapping.getKotlinFunction(constructor);
+			if (function == null) {
+				return;
+			}
+			int index = 0;
+			for (KParameter parameter : function.getParameters()) {
+				switch (parameter.getKind()) {
+					case VALUE, EXTENSION_RECEIVER -> {
+						Object rawValue = arguments[index];
+						if (!(parameter.isOptional() && rawValue == null)) {
+							KType type = parameter.getType();
+							if (!(type.isMarkedNullable() && rawValue == null) && type.getClassifier() instanceof KClass<?> kClass
+									&& KotlinDetector.isInlineClass(JvmClassMappingKt.getJavaClass(kClass))) {
+								KFunction<?> argConstructor = KClasses.getPrimaryConstructor(kClass);
+								if (argConstructor != null) {
+									if (!KCallablesJvm.isAccessible(argConstructor)) {
+										KCallablesJvm.setAccessible(argConstructor, true);
+									}
+									arguments[index] = argConstructor.call(rawValue);
+								}
+							}
+						}
+					}
+				}
+				index++;
+			}
+		}
+	}
+
 }

spring-graphql/src/test/kotlin/org/springframework/graphql/data/GraphQlArgumentBinderKotlinTests.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2025-present 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.data
+
+import com.fasterxml.jackson.core.type.TypeReference
+import com.fasterxml.jackson.databind.json.JsonMapper
+import graphql.schema.DataFetchingEnvironment
+import graphql.schema.DataFetchingEnvironmentImpl
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.core.ResolvableType
+import org.springframework.format.support.DefaultFormattingConversionService
+import org.springframework.lang.Nullable
+
+class GraphQlArgumentBinderKotlinTests {
+
+    private val mapper = JsonMapper.builder().build()
+
+    private val binder = GraphQlArgumentBinder(DefaultFormattingConversionService())
+
+    @Test
+    fun bindValueClass() {
+        val targetType = ResolvableType.forClass(MyDataClassWithValueClass::class.java)
+        val result = bind(binder, "{\"first\": \"firstValue\", \"second\": \"secondValue\"}", targetType) as MyDataClassWithValueClass
+        assertThat(result.first).isEqualTo("firstValue")
+        assertThat(result.second).isEqualTo(MyValueClass("secondValue"))
+    }
+
+    @Test
+    fun bindValueClassWithDefaultValue() {
+        val targetType = ResolvableType.forClass(MyDataClassWithDefaultValueClass::class.java)
+        val result = bind(binder, "{\"first\": \"firstValue\"}", targetType) as MyDataClassWithDefaultValueClass
+        assertThat(result.first).isEqualTo("firstValue")
+
+    }
+
+    @Nullable
+    @Throws(Exception::class)
+    private fun bind(binder: GraphQlArgumentBinder, json: String, targetType: ResolvableType): Any? {
+        val typeRef: TypeReference<Map<String, Any>> = object : TypeReference<Map<String, Any>>() {}
+        val map = this.mapper.readValue("{\"key\":$json}", typeRef)
+        val environment: DataFetchingEnvironment =
+            DataFetchingEnvironmentImpl.newDataFetchingEnvironment()
+                .arguments(map)
+                .build()
+        return binder.bind(environment, "key", targetType)
+    }
+
+    data class MyDataClassWithValueClass(val first: String, val second: MyValueClass)
+
+    data class MyDataClassWithDefaultValueClass(val first: String, val second: MyValueClass = MyValueClass("secondValue"))
+
+    @JvmInline
+    value class MyValueClass(val value: String) {
+
+    }
+
+}