feat: Implement KotlinCallableCustom to enable lambda callables (#657)

harness/tests/scripts/godot/tests/Invocation.gdj

@@ -6,20 +6,20 @@ fqName = godot.tests.Invocation
 relativeSourcePath = src/main/kotlin/godot/tests/Invocation.kt
 baseType = Node3D
 supertypes = [
-    godot.Node3D,
+	godot.Node3D,
 	godot.Node,
 	godot.Object,
 	godot.core.KtObject,
 	kotlin.Any
 ]
 signals = [
-    no_param,
+	no_param,
 	one_param,
 	two_param,
 	signal_with_multiple_targets
 ]
 properties = [
-    button,
+	button,
 	enum_list,
 	vector_list,
 	enum_list_mutable,
@@ -78,7 +78,7 @@ properties = [
 	array
 ]
 functions = [
-    target_function_one,
+	target_function_one,
 	target_function_two,
 	int_value,
 	long_value,
@@ -171,4 +171,4 @@ functions = [
 	nullable_string_is_null,
 	nullable_return_type,
 	create_variant_array_of_user_type
-]
+]

harness/tests/scripts/godot/tests/LambdaCallableTest.gdj

@@ -0,0 +1,30 @@
+// THIS FILE IS GENERATED! DO NOT EDIT OR DELETE IT. EDIT OR DELETE THE ASSOCIATED SOURCE CODE FILE INSTEAD
+// Note: You can however freely move this file inside your godot project if you want. Keep in mind however, that if you rename the originating source code file, this file will be deleted and regenerated as a new file instead of being updated! Other modifications to the source file however, will result in this file being updated.
+
+registeredName = LambdaCallableTest
+fqName = godot.tests.LambdaCallableTest
+relativeSourcePath = src/main/kotlin/godot/tests/LambdaCallableTest.kt
+baseType = Node
+supertypes = [
+    godot.Node,
+	godot.Object,
+	godot.core.KtObject,
+	kotlin.Any
+]
+signals = [
+    signal_no_param,
+	signal_with_params
+]
+properties = [
+    has_signal_no_param_been_triggered,
+	signal_string,
+	signal_long,
+	signal_node,
+	kt_callable,
+	kt_callable_string
+]
+functions = [
+    _ready,
+	emit_signal_no_param,
+	emit_signal_with_param
+]

harness/tests/src/main/java/godot/tests/JavaTestClass.java

@@ -3,7 +3,7 @@
 import godot.Button;
 import godot.Node;
 import godot.annotation.*;
-import godot.core.Callable;
+import godot.core.NativeCallable;
 import godot.core.StringNameUtils;
 import godot.signals.Signal;
 import godot.signals.Signal2;
@@ -70,7 +70,7 @@ public String greeting() {
     public void connectAndTriggerSignal() {
         connect(
                 StringNameUtils.asStringName("test_signal"),
-                new Callable(this, StringNameUtils.asStringName("signal_callback")),
+                new NativeCallable(this, StringNameUtils.asStringName("signal_callback")),
                 (int) ConnectFlags.CONNECT_ONE_SHOT.getId()
         );
         emitSignal(StringNameUtils.asStringName("test_signal"));

harness/tests/src/main/kotlin/godot/tests/Invocation.kt

@@ -42,6 +42,7 @@ import godot.core.dictionaryOf
 import godot.core.variantArrayOf
 import godot.extensions.getNodeAs
 import godot.registration.Range
+import godot.signals.connect
 import godot.signals.signal
 import godot.tests.subpackage.OtherScript
 import godot.util.RealT
@@ -407,6 +408,10 @@ class Invocation : Node3D() {
 		oneParam.connect(invocation, OtherScript::hookOneParam)
 		twoParam.connect(invocation, OtherScript::hookTwoParam)
 
+		noParam.connect { println("noParam signal emitted") }
+		oneParam.connect { b -> println("oneParam signal emitted with $b") }
+		twoParam.connect { p0, p1 -> println("twoParam signal emitted with $p0 and $p1") }
+
 		signalWithMultipleTargets.connect(this, Invocation::targetFunctionOne)
 		signalWithMultipleTargets.connect(this, Invocation::targetFunctionTwo)
 

harness/tests/src/main/kotlin/godot/tests/LambdaCallableTest.kt

@@ -0,0 +1,61 @@
+package godot.tests
+
+import godot.Node
+import godot.annotation.RegisterClass
+import godot.annotation.RegisterFunction
+import godot.annotation.RegisterProperty
+import godot.annotation.RegisterSignal
+import godot.core.callable.asCallable
+import godot.signals.connect
+import godot.signals.signal
+
+@RegisterClass
+class LambdaCallableTest : Node() {
+
+    @RegisterSignal
+    val signalNoParam by signal()
+
+    @RegisterProperty
+    var hasSignalNoParamBeenTriggered = false
+
+    @RegisterSignal
+    val signalWithParams by signal<String, Long, Node>("str", "long", "node")
+
+    @RegisterProperty
+    lateinit var signalString: String
+
+    @RegisterProperty
+    var signalLong: Long = Long.MIN_VALUE
+
+    @RegisterProperty
+    lateinit var signalNode: Node
+
+    @RegisterProperty
+    var ktCallable = { str: String -> ktCallableString = str }.asCallable()
+
+    @RegisterProperty
+    lateinit var ktCallableString: String
+
+    @RegisterFunction
+    override fun _ready() {
+        signalNoParam.connect {
+            hasSignalNoParamBeenTriggered = true
+        }
+
+        signalWithParams.connect { p0, p1, p2 ->
+            signalString = p0
+            signalLong = p1
+            signalNode = p2
+        }
+    }
+
+    @RegisterFunction
+    fun emitSignalNoParam() {
+        signalNoParam.emit()
+    }
+
+    @RegisterFunction
+    fun emitSignalWithParam(str: String, long: Long, node: Node) {
+        signalWithParams.emit(str, long, node)
+    }
+}

harness/tests/src/main/kotlin/godot/tests/callable/CallableMethodBindTest.kt

@@ -4,7 +4,7 @@ import godot.Node
 import godot.annotation.RegisterClass
 import godot.annotation.RegisterFunction
 import godot.annotation.RegisterProperty
-import godot.core.Callable
+import godot.core.NativeCallable
 import godot.core.VariantArray
 import godot.core.variantArrayOf
 import godot.global.GD
@@ -16,22 +16,22 @@ class CallableMethodBindTest: Node() {
 
     @RegisterFunction
     fun callWithMethodWithAllBinds() {
-        Callable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(1, 2, 3).call()
+        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(1, 2, 3).call()
     }
 
     @RegisterFunction
     fun callWithMethodWithTwoBinds() {
-        Callable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(2, 3).call(0)
+        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(2, 3).call(0)
     }
 
     @RegisterFunction
     fun callWithMethodWithOneBind() {
-        Callable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(3).call(0, 0)
+        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind(3).call(0, 0)
     }
 
     @RegisterFunction
     fun callWithMethodWithNoBind() {
-        Callable(this, CallableMethodBindTest::readySignalMethodBindTest).bind().call(0, 0, 0)
+        NativeCallable(this, CallableMethodBindTest::readySignalMethodBindTest).bind().call(0, 0, 0)
     }
 
     @RegisterFunction

harness/tests/test/unit/test_lambda_callable.gd

@@ -0,0 +1,36 @@
+extends "res://addons/gut/test.gd"
+
+
+func test_signal_without_param():
+	var lambda_callable_test_script = LambdaCallableTest.new()
+	get_tree().root.add_child(lambda_callable_test_script)
+	lambda_callable_test_script.emit_signal_no_param()
+	assert_true(lambda_callable_test_script.has_signal_no_param_been_triggered)
+	get_tree().root.remove_child(lambda_callable_test_script)
+	lambda_callable_test_script.free()
+
+func test_signal_with_param():
+	var lambda_callable_test_script = LambdaCallableTest.new()
+	get_tree().root.add_child(lambda_callable_test_script)
+
+	var expected_str = "expected"
+	var expected_int = randi()
+	var expected_node = lambda_callable_test_script
+
+	lambda_callable_test_script.emit_signal_with_param(expected_str, expected_int, expected_node)
+
+	assert_eq(lambda_callable_test_script.signal_string, expected_str)
+	assert_eq(lambda_callable_test_script.signal_long, expected_int)
+	assert_eq(lambda_callable_test_script.signal_node, expected_node)
+	get_tree().root.remove_child(lambda_callable_test_script)
+	lambda_callable_test_script.free()
+
+func test_kotlin_lambda_call_from_gdscript():
+	var lambda_callable_test_script = LambdaCallableTest.new()
+
+	var expected_str = "expected"
+
+	lambda_callable_test_script.kt_callable.call(expected_str)
+
+	assert_eq(lambda_callable_test_script.kt_callable_string, expected_str)
+	lambda_callable_test_script.free()

kt/api-generator/src/main/kotlin/godot/codegen/extensions/TypedExtensions.kt

@@ -8,14 +8,15 @@ import com.squareup.kotlinpoet.LONG
 import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.UNIT
 import godot.codegen.constants.GodotMeta
-import godot.codegen.models.enriched.EnrichedEnum
 import godot.codegen.models.enriched.EnrichedSignal
 import godot.codegen.poet.ClassTypeNameWrapper
 import godot.codegen.traits.CastableTrait
 import godot.codegen.traits.NullableTrait
 import godot.codegen.traits.TypedTrait
 import godot.codegen.traits.WithDefaultValueTrait
 import godot.tools.common.constants.GODOT_ARRAY
+import godot.tools.common.constants.GODOT_CALLABLE
+import godot.tools.common.constants.GODOT_CALLABLE_BASE
 import godot.tools.common.constants.GODOT_DICTIONARY
 import godot.tools.common.constants.GODOT_ERROR
 import godot.tools.common.constants.GodotKotlinJvmTypes
@@ -126,6 +127,7 @@ fun TypedTrait.getTypeClassName(): ClassTypeNameWrapper {
         type == GodotTypes.dictionary -> ClassTypeNameWrapper(GODOT_DICTIONARY)
             .parameterizedBy(ANY.copy(nullable = true), ANY.copy(nullable = true))
         type == GodotTypes.variant -> ClassTypeNameWrapper(ANY)
+        type == GodotTypes.callable -> ClassTypeNameWrapper(GODOT_CALLABLE_BASE)
         isCoreType() -> ClassTypeNameWrapper(ClassName(godotCorePackage, type!!))
         else -> ClassTypeNameWrapper(ClassName(godotApiPackage, type!!))
     }
@@ -167,20 +169,20 @@ val TypedTrait.jvmVariantTypeValue: ClassName
         }
     }
 
-fun <T> T.getDefaultValueKotlinString(): String?
+fun <T> T.getDefaultValueKotlinString(): Pair<String, Array<Any?>>?
     where T : WithDefaultValueTrait,
           T : NullableTrait,
           T : CastableTrait {
     val defaultValueString = defaultValue ?: return null
     return when {
-        nullable && defaultValue == "null" -> defaultValueString
-        type == GodotTypes.color -> "${GodotKotlinJvmTypes.color}($defaultValueString)"
-        type == GodotTypes.variant -> defaultValueString
-        type == GodotTypes.bool -> defaultValueString.lowercase(Locale.US)
-        type == GodotTypes.float && meta == GodotMeta.Float.float -> "${intToFloat(defaultValueString)}f"
-        type == GodotTypes.float -> intToFloat(defaultValueString)
+        nullable && defaultValue == "null" -> defaultValueString to arrayOf()
+        type == GodotTypes.color -> "${GodotKotlinJvmTypes.color}($defaultValueString)" to arrayOf()
+        type == GodotTypes.variant -> defaultValueString to arrayOf()
+        type == GodotTypes.bool -> defaultValueString.lowercase(Locale.US) to arrayOf()
+        type == GodotTypes.float && meta == GodotMeta.Float.float -> "${intToFloat(defaultValueString)}f" to arrayOf()
+        type == GodotTypes.float -> intToFloat(defaultValueString) to arrayOf()
         type == GodotTypes.stringName -> "${GodotKotlinJvmTypes.stringName}(".plus(defaultValueString.replace("&", ""))
-            .plus(")")
+            .plus(")") to arrayOf()
 
         type == GodotTypes.array || isTypedArray() ->
             if (defaultValueString.startsWith("Array")) {
@@ -192,14 +194,15 @@ fun <T> T.getDefaultValueKotlinString(): String?
                 "$godotCorePackage.variantArrayOf("
                     .plus(defaultValueString.removePrefix("[").removeSuffix("]"))
                     .plus(")")
-            }
+            } to arrayOf()
 
         type == GodotTypes.rect2 -> defaultValueString
             .replace(",", ".0,")
-            .replace(")", ".0)")
+            .replace(")", ".0)") to arrayOf()
+
+        type == GodotTypes.callable -> "%T()" to arrayOf(GODOT_CALLABLE)
 
         type == GodotTypes.rid ||
-            type == GodotTypes.callable ||
             type == GodotTypes.dictionary ||
             type == GodotTypes.transform2D ||
             type == GodotTypes.transform3D ||
@@ -212,9 +215,9 @@ fun <T> T.getDefaultValueKotlinString(): String?
             type == GodotTypes.packedInt64Array ||
             type == GodotTypes.packedVector2Array ||
             type == GodotTypes.packedVector3Array
-        -> "$type()"
+        -> "$type()" to arrayOf()
 
-        else -> defaultValueString
+        else -> defaultValueString to arrayOf()
     }
 }
 

kt/api-generator/src/main/kotlin/godot/codegen/generationEntry.kt

@@ -11,6 +11,7 @@ import godot.codegen.repositories.*
 import godot.codegen.repositories.impl.*
 import godot.codegen.services.*
 import godot.codegen.services.impl.*
+import godot.tools.common.constants.Constraints
 import godot.tools.common.constants.GENERATED_COMMENT
 import java.io.File
 
@@ -78,4 +79,7 @@ fun File.generateApiFrom(jsonSource: File, docsDir: File? = null) {
             .build()
             .writeTo(this)
     }
+
+    KtCallableGenerationService().generate(Constraints.MAX_FUNCTION_ARG_COUNT).writeTo(this)
+    SignalGenerationService().generate(Constraints.MAX_FUNCTION_ARG_COUNT).writeTo(this)
 }

kt/api-generator/src/main/kotlin/godot/codegen/services/IKtCallableGenerationService.kt

@@ -0,0 +1,7 @@
+package godot.codegen.services
+
+import com.squareup.kotlinpoet.FileSpec
+
+interface IKtCallableGenerationService {
+    fun generate(maxArgumentCount: Int): FileSpec
+}

kt/api-generator/src/main/kotlin/godot/codegen/services/ISignalGenerationService.kt

@@ -0,0 +1,7 @@
+package godot.codegen.services
+
+import com.squareup.kotlinpoet.FileSpec
+
+interface ISignalGenerationService {
+    fun generate(maxArgumentCount: Int): FileSpec
+}