Propagate exception to wasm-js and js in propagateExceptionFinalResort

kotlinx-coroutines-core/common/src/internal/CoroutineExceptionHandlerImpl.common.kt

@@ -15,7 +15,7 @@ internal expect val platformExceptionHandlers: Collection<CoroutineExceptionHand
 internal expect fun ensurePlatformExceptionHandlerLoaded(callback: CoroutineExceptionHandler)
 
 /**
- * The platform-dependent global exception handler, used so that the exception is logged at least *somewhere*.
+ * The platform-dependent global exception handler, used so that the exception is processed at least *somewhere*.
  */
 internal expect fun propagateExceptionFinalResort(exception: Throwable)
 

kotlinx-coroutines-core/js/src/internal/CoroutineExceptionHandlerImpl.kt

@@ -1,8 +1,7 @@
 package kotlinx.coroutines.internal
 
-import kotlinx.coroutines.*
+import kotlin.js.unsafeCast
 
-internal actual fun propagateExceptionFinalResort(exception: Throwable) {
-    // log exception
-    console.error(exception.toString())
-}
+internal actual external interface JsAny
+
+internal actual fun Throwable.toJsException(): JsAny = this.unsafeCast<JsAny>()

kotlinx-coroutines-core/js/test/PropagateExceptionFinalResortTest.kt

@@ -0,0 +1,50 @@
+package kotlinx.coroutines
+
+import kotlinx.coroutines.testing.*
+import kotlin.js.*
+import kotlin.test.*
+
+class PropagateExceptionFinalResortTest : TestBase() {
+    @BeforeTest
+    fun removeListeners() {
+        // Remove a Node.js's internal listener, which prints the exception to stdout.
+        js("""
+            globalThis.originalListeners = process.listeners('uncaughtException');
+            process.removeAllListeners('uncaughtException');
+        """)
+    }
+
+    @AfterTest
+    fun restoreListeners() {
+        js("""
+            if (globalThis.originalListeners) {
+                process.removeAllListeners('uncaughtException');
+                globalThis.originalListeners.forEach(function(listener) {
+                    process.on('uncaughtException', listener);
+                });
+            }
+        """)
+    }
+
+    /*
+     * Test that `propagateExceptionFinalResort` re-throws the exception on JS.
+     *
+     * It is checked by setting up an exception handler within JS.
+     */
+    @Test
+    fun testThrows() = runTest {
+        js("""
+            globalThis.exceptionCaught = false;
+            process.on('uncaughtException', function(e) {
+                globalThis.exceptionCaught = true;
+            });
+        """)
+        val job = GlobalScope.launch {
+            throw IllegalStateException("My ISE")
+        }
+        job.join()
+        delay(1)  // Let the exception be re-thrown and handled.
+        val exceptionCaught = js("globalThis.exceptionCaught") as Boolean
+        assertTrue(exceptionCaught)
+    }
+}

kotlinx-coroutines-core/jsAndWasmJsShared/src/internal/CoroutineExceptionHandlerImpl.kt

@@ -0,0 +1,17 @@
+package kotlinx.coroutines.internal
+
+import kotlinx.coroutines.*
+
+internal expect interface JsAny
+
+internal expect fun Throwable.toJsException(): JsAny
+
+/*
+ * Schedule an exception to be thrown inside JS or Wasm/JS event loop,
+ * rather than in the current execution branch.
+ */
+internal fun throwAsync(e: JsAny): Unit = js("setTimeout(function () { throw e }, 0)")
+
+internal actual fun propagateExceptionFinalResort(exception: Throwable) {
+    throwAsync(exception.toJsException())
+}

kotlinx-coroutines-core/wasmJs/src/internal/CoroutineExceptionHandlerImpl.kt

@@ -1,8 +1,16 @@
 package kotlinx.coroutines.internal
 
-import kotlinx.coroutines.*
+internal actual typealias JsAny = kotlin.js.JsAny
 
-internal actual fun propagateExceptionFinalResort(exception: Throwable) {
-    // log exception
-    console.error(exception.toString())
-}
+internal actual fun Throwable.toJsException(): JsAny =
+    toJsError(message, this::class.simpleName, stackTraceToString())
+
+internal fun toJsError(message: String?, className: String?, stack: String?): JsAny {
+    js("""
+    const error = new Error();
+    error.message = message;
+    error.name = className;
+    error.stack = stack;
+    return error;
+    """)
+}

kotlinx-coroutines-core/wasmJs/test/PropagateExceptionFinalResortTest.kt

@@ -0,0 +1,33 @@
+package kotlinx.coroutines
+
+import kotlinx.coroutines.testing.TestBase
+import kotlin.test.*
+
+class PropagateExceptionFinalResortTest : TestBase() {
+    /*
+     * Test that `propagateExceptionFinalResort` re-throws the exception on Wasm/JS.
+     *
+     * It is checked by setting up an exception handler within Wasm/JS.
+     */
+    @Test
+    fun testThrows() = runTest {
+        addUncaughtExceptionHandler()
+        val job = GlobalScope.launch {
+            throw IllegalStateException("My ISE")
+        }
+        job.join()
+        delay(1)  // Let the exception be re-thrown and handled.
+        assertTrue(exceptionCaught())
+    }
+}
+
+private fun addUncaughtExceptionHandler() {
+    js("""
+        globalThis.exceptionCaught = false;
+        process.on('uncaughtException', function(e) {
+            globalThis.exceptionCaught = true;
+        });
+    """)
+}
+
+private fun exceptionCaught(): Boolean = js("globalThis.exceptionCaught")