Improve coroutine dispatcher (#933)

Author: CedNaru

kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/AwaitFrames.kt

@@ -1,22 +1,15 @@
 package godot.coroutines
 
-import kotlinx.coroutines.async
+import kotlinx.coroutines.withContext
 
 suspend inline fun <R> awaitProcessFrame(
     crossinline block: () -> R
-): R {
-    val job = GodotCoroutine.async(GodotDispatchers.ProcessFrame) {
-        block()
-    }
-    return job.await()
+): R = withContext(GodotDispatchers.ProcessFrame) {
+    block()
 }
 
 suspend inline fun <R> awaitPhysicsFrame(
     crossinline block: () -> R
-): R {
-    val job = GodotCoroutine.async(GodotDispatchers.PhysicsFrame) {
-        block()
-    }
-
-    return job.await()
+): R = withContext(GodotDispatchers.PhysicsFrame) {
+    block()
 }

kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/GodotDispatchers.kt

@@ -11,6 +11,7 @@ import kotlinx.coroutines.Runnable
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 import kotlin.coroutines.CoroutineContext
+import godot.api.Thread as GodotThread
 
 object GodotDispatchers {
 
@@ -20,6 +21,23 @@ object GodotDispatchers {
     val PhysicsFrame: CoroutineDispatcher = GodotPhysicsFrameCoroutineDispatcher
 
     private object GodotMainThreadCoroutineDispatcher : CoroutineDispatcher() {
+        @Volatile
+        private var cachedMainThread: Thread? = null
+
+        override fun isDispatchNeeded(context: CoroutineContext): Boolean {
+            val current = Thread.currentThread()
+            val cached = cachedMainThread
+            // Already on the main thread → no dispatch needed.
+            if (cached != null) return cached !== current
+
+            // Slow path: ask Godot. Caches on success so subsequent checks are JNI-free.
+            if (GodotThread.isMainThread()) {
+                cachedMainThread = current
+                return false
+            }
+            return true
+        }
+
         override fun dispatch(context: CoroutineContext, block: Runnable) {
             { block.run() }.asCallable().callDeferred()
         }

kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/awaitMainThread.kt

@@ -1,22 +1,21 @@
 package godot.coroutines
 
-import kotlinx.coroutines.async
+import kotlinx.coroutines.withContext
 
 
 /**
- * Suspends the current coroutine until the given block is executed.
+ * Suspends the current coroutine until the given block is executed on Godot's main thread.
  *
- * The block will be executed at the end of the frame on the main thread.
+ * If the caller is already on the main thread, the block runs synchronously on the current stack.
+ * Otherwise the block is posted to the main thread via `callDeferred` and runs at the end of the
+ * current frame.
  *
- * Use it to call not thread safe code from godot and wait for the execution of it.
+ * Use it to call not-thread-safe Godot code and wait for its result.
  *
- * @param block the code block to execute at the end of the frame
+ * @param block the code block to execute on the main thread
  */
 suspend inline fun <R> awaitMainThread(
     crossinline block: () -> R
-): R {
-    val job = GodotCoroutine.async(GodotDispatchers.MainThread) {
-        block()
-    }
-    return job.await()
+): R = withContext(GodotDispatchers.MainThread) {
+    block()
 }

kt/godot-library/godot-coroutine-library/src/main/kotlin/godot/coroutines/awaitResourceLoad.kt

@@ -3,7 +3,7 @@ package godot.coroutines
 import godot.api.Resource
 import godot.api.ResourceLoader
 import godot.api.ResourceLoader.CacheMode
-import kotlinx.coroutines.async
+import kotlinx.coroutines.withContext
 
 
 /**
@@ -14,7 +14,7 @@ import kotlinx.coroutines.async
  * @param cacheMode The cache mode to be used while loading the resource.
  * @return The loaded resource, or null if there was an error.
  */
-public suspend inline fun ResourceLoader.awaitLoad(
+suspend inline fun ResourceLoader.awaitLoad(
     path: String,
     typeHint: String = "",
     cacheMode: CacheMode = CacheMode.REUSE,
@@ -24,12 +24,11 @@ public suspend inline fun ResourceLoader.awaitLoad(
         return load(path)
     }
 
-    // Start a new job so we have a suspension point in case the coroutine is currently in the main thread.
-    val job = GodotCoroutine.async(GodotDispatchers.ThreadPool) {
+    // Switch to the worker thread pool so the load doesn't block the caller's thread
+    // (especially important when the caller is on the main thread).
+    return withContext(GodotDispatchers.ThreadPool) {
         load(path, typeHint, cacheMode)
     }
-
-    return job.await()
 }
 
 /**
@@ -40,7 +39,7 @@ public suspend inline fun ResourceLoader.awaitLoad(
  * @param cacheMode The cache mode to be used while loading the resource.
  * @return The loaded resource, or null if there was an error.
  */
-public suspend inline fun <R> ResourceLoader.awaitLoadAs(
+suspend inline fun <R> ResourceLoader.awaitLoadAs(
     path: String,
     typeHint: String = "",
     cacheMode: CacheMode = CacheMode.REUSE,

kt/plugins/godot-intellij-plugin/src/main/resources/META-INF/plugin.xml

@@ -22,7 +22,7 @@
 
     <resource-bundle>messages.generalLabels</resource-bundle>
 
-    <depends>com.intellij.modules.java</depends>
+    <depends>com.intellij.java</depends>
     <depends>org.jetbrains.kotlin</depends>
     <depends optional="true" config-file="godotjvmideaplugin-with-scala.xml">org.intellij.scala</depends>
 </idea-plugin>