Fix signal.await() when signal belongs to a Node (#710)

* Fix connect on nodes

Author: CedNaru

harness/tests/src/main/kotlin/godot/tests/coroutine/CoroutineTest.kt

@@ -12,10 +12,10 @@ import godot.core.Vector2
 import godot.core.signal0
 import godot.core.signal1
 import godot.core.signal4
-import godot.coroutines.GodotCoroutine
+import godot.coroutines.godotCoroutine
 import godot.coroutines.await
-import godot.coroutines.awaitDeferred
 import godot.coroutines.awaitLoadAs
+import godot.coroutines.awaitMainThread
 import godot.global.GD
 import kotlinx.coroutines.CoroutineStart
 
@@ -35,27 +35,27 @@ class CoroutineTest : Object() {
     var step: Int = 0
 
     @RegisterFunction
-    fun startCoroutineWithoutParameter() = GodotCoroutine {
+    fun startCoroutineWithoutParameter() = godotCoroutine {
         step = 1
         signalWithoutParameter.await()
         step = 2
     }
 
     @RegisterFunction
-    fun startCoroutineWithOneParameter() = GodotCoroutine {
+    fun startCoroutineWithOneParameter() = godotCoroutine {
         step = 3
         step = signalWithOneParameter.await()
     }
 
     @RegisterFunction
-    fun startCoroutineWithManyParameters() = GodotCoroutine {
+    fun startCoroutineWithManyParameters() = godotCoroutine {
         step = 5
         val (int, _, _, _) = signalWithManyParameters.await()
         step = int
     }
 
     @RegisterFunction
-    fun startCoroutineUndispatched() = GodotCoroutine(start = CoroutineStart.UNDISPATCHED) {
+    fun startCoroutineUndispatched() = godotCoroutine(start = CoroutineStart.UNDISPATCHED) {
         step = 7
         signalWithoutParameter.await()
         step = 8
@@ -68,19 +68,19 @@ class CoroutineTest : Object() {
     fun runOnMainThreadFromBackgroundThread() {
         val thread = Thread.currentThread().name
 
-        GodotCoroutine {
+        godotCoroutine {
             val bgThread = Thread.currentThread().name
 
             var fgThread = ""
-            awaitDeferred {
+            awaitMainThread {
                 fgThread = Thread.currentThread().name
             }
 
             val bg2Thread = Thread.currentThread().name
 
             GD.print("Thread names: ${listOf(thread, bgThread, fgThread, bg2Thread).joinToString()}")
 
-            awaitDeferred {
+            awaitMainThread {
                 runOnMainThreadFromBackgroundThreadFinished.emit(
                     thread != bgThread
                         && thread != bg2Thread
@@ -96,14 +96,14 @@ class CoroutineTest : Object() {
 
     @RegisterFunction
     fun asyncLoadResource() {
-        GodotCoroutine {
+        godotCoroutine {
             val resource = ResourceLoader.awaitLoadAs<PackedScene>("res://Spatial.tscn") { progress ->
                 GD.print("Resource load progress: $progress")
             }
 
             GD.print("Resource: $resource")
 
-            awaitDeferred {
+            awaitMainThread {
                 asyncLoadResourceFinished.emit(resource != null)
             }
         }

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

@@ -22,7 +22,7 @@ import godot.tools.common.constants.kotlinxCoroutinePackage
 
 private val cancellableContinuationClass = ClassName(kotlinxCoroutinePackage, "CancellableContinuation")
 private val suspendCancellableCoroutine = MemberName(kotlinxCoroutinePackage, "suspendCancellableCoroutine")
-private val connect = MemberName(godotCorePackage, "connect")
+private val connect = MemberName(godotCorePackage, "connectThreadSafe")
 private val resume = MemberName(kotlinCoroutinePackage, "resume")
 
 object AwaitGenerationService : IAwaitGenerationService {

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

@@ -98,7 +98,8 @@ class SignalGenerationService : ISignalGenerationService {
 
             signalFileSpec.addFunction(generateFakeSignalConstructor(argCount, genericClassNameInfo))
             signalFileSpec.addFunction(generateSignalDelegate(argCount, genericClassNameInfo))
-            signalFileSpec.addFunction(generateSignalExtension(genericClassNameInfo))
+            signalFileSpec.addFunction(generateSignalExtension(genericClassNameInfo, false))
+            signalFileSpec.addFunction(generateSignalExtension(genericClassNameInfo, true))
         }
 
         return signalFileSpec
@@ -179,6 +180,19 @@ class SignalGenerationService : ISignalGenerationService {
                         .addCode(generateConnectionCodeBlock())
                         .build(),
 
+                    FunSpec.builder(CONNECT_THREAD_SAFE_METHOD_NAME)
+                        .addTypeVariable(godotObjectBoundTypeVariable)
+                        .addParameters(
+                            listOf(
+                                ParameterSpec.builder(TARGET_PARAMETER_NAME, godotObjectBoundTypeVariable).build(),
+                                ParameterSpec.builder(METHOD_PARAMETER_NAME, lambdaTypeName).build(),
+                                flagsParameter
+                            )
+                        )
+                        .returns(ANY.copy(nullable = true))
+                        .addCode(generateConnectionCodeBlock(false, true))
+                        .build(),
+
                     FunSpec.builder(DISCONNECT_METHOD_NAME)
                         .addTypeVariable(godotObjectBoundTypeVariable)
                         .addParameters(
@@ -196,8 +210,16 @@ class SignalGenerationService : ISignalGenerationService {
             .build()
     }
 
-    private fun generateConnectionCodeBlock(isDisconnect: Boolean = false): CodeBlock {
-        val methodName = if (isDisconnect) DISCONNECT_METHOD_NAME else CONNECT_METHOD_NAME
+    private fun generateConnectionCodeBlock(isDisconnect: Boolean = false, isThreadSafe: Boolean = false): CodeBlock {
+        val methodName = if (isDisconnect) {
+            DISCONNECT_METHOD_NAME
+        } else {
+            if (isThreadSafe) {
+                CONNECT_THREAD_SAFE_METHOD_NAME
+            } else {
+                CONNECT_METHOD_NAME
+            }
+        }
         val flagsParameters = if (isDisconnect) "" else ",·$FLAGS_PARAMETER_NAME"
 
         return CodeBlock.of(
@@ -301,37 +323,37 @@ class SignalGenerationService : ISignalGenerationService {
         val genericReadOnlyPropertyClassName = readOnlyPropertyClassName.parameterizedBy(GODOT_OBJECT, genericClassNameInfo.genericClassName)
 
         return genericClassNameInfo
-                .toFunSpecBuilder(SIGNAL_METHOD_NAME + argCount)
-                .addModifiers(KModifier.INLINE)
-                .receiver(GODOT_OBJECT)
-                .addParameters(
-                    (0..<argCount)
-                        .map {
-                            ParameterSpec.builder("p$it", STRING).build()
-                        }
-                )
-                .addCode(
-                    if (argCount == 0) {
-                        CodeBlock.of("return·%T.$DELEGATE_PROPERTY_NAME", genericClassNameInfo.className)
-                    } else {
-                        CodeBlock.of("return·%T.$DELEGATE_PROPERTY_NAME·as·%T", genericClassNameInfo.className, genericReadOnlyPropertyClassName)
-                    }
-                )
-                .apply {
-                    if (argCount != 0) {
-                        addAnnotation(
-                            AnnotationSpec
-                                .builder(Suppress::class)
-                                .addMember("\"UNCHECKED_CAST\"")
-                                .build()
-                        )
+            .toFunSpecBuilder(SIGNAL_METHOD_NAME + argCount)
+            .addModifiers(KModifier.INLINE)
+            .receiver(GODOT_OBJECT)
+            .addParameters(
+                (0..<argCount)
+                    .map {
+                        ParameterSpec.builder("p$it", STRING).build()
                     }
+            )
+            .addCode(
+                if (argCount == 0) {
+                    CodeBlock.of("return·%T.$DELEGATE_PROPERTY_NAME", genericClassNameInfo.className)
+                } else {
+                    CodeBlock.of("return·%T.$DELEGATE_PROPERTY_NAME·as·%T", genericClassNameInfo.className, genericReadOnlyPropertyClassName)
+                }
+            )
+            .apply {
+                if (argCount != 0) {
+                    addAnnotation(
+                        AnnotationSpec
+                            .builder(Suppress::class)
+                            .addMember("\"UNCHECKED_CAST\"")
+                            .build()
+                    )
                 }
-                .build()
+            }
+            .build()
     }
 
 
-    private fun generateSignalExtension(genericClassNameInfo: GenericClassNameInfo): FunSpec {
+    private fun generateSignalExtension(genericClassNameInfo: GenericClassNameInfo, isThreadSafe: Boolean): FunSpec {
         val flagsParameter = ParameterSpec.builder(FLAGS_PARAMETER_NAME, INT)
             .defaultValue("0")
             .build()
@@ -346,23 +368,34 @@ class SignalGenerationService : ISignalGenerationService {
             .addModifiers(KModifier.NOINLINE)
             .build()
 
+        val methodName = if (isThreadSafe) {
+            CONNECT_THREAD_SAFE_METHOD_NAME
+        } else {
+            CONNECT_METHOD_NAME
+        }
+
         return genericClassNameInfo
-            .toReifiedExtensionFunSpecBuilder(CONNECT_METHOD_NAME)
+            .toReifiedExtensionFunSpecBuilder(methodName)
             .addParameters(
                 listOf(
                     flagsParameter,
                     signalConnectExtensionGenericParameters
                 )
             )
             .addCode(
-                "return·$CONNECT_METHOD_NAME($METHOD_PARAMETER_NAME.%M(),·$FLAGS_PARAMETER_NAME)",
+                "return·$methodName($METHOD_PARAMETER_NAME.%M(),·$FLAGS_PARAMETER_NAME)",
                 AS_CALLABLE_UTIL_FUNCTION
             )
-            .returns(GODOT_ERROR)
+            .returns(
+                if (isThreadSafe) {
+                    ANY.copy(nullable = true)
+                } else {
+                    GODOT_ERROR
+                }
+            )
             .build()
     }
 
-
     companion object {
         private const val SIGNAL_CLASS_NAME = "Signal"
         private const val INSTANCE_PARAMETER = "instance"
@@ -375,6 +408,7 @@ class SignalGenerationService : ISignalGenerationService {
 
         private const val EMIT_METHOD_NAME = "emit"
         private const val CONNECT_METHOD_NAME = "connect"
+        private const val CONNECT_THREAD_SAFE_METHOD_NAME = "connectThreadSafe"
         private const val DISCONNECT_METHOD_NAME = "disconnect"
         private const val SIGNAL_METHOD_NAME = "signal"
         private const val JAVA_CREATE_METHOD_NAME = "javaCreate"