AMEND Create intermediate js-wasm sourceSet

igoriakovlev · igoriakovlev · commit 0d98f084afcd · 2023-09-18T18:29:17.000+02:00
diff --git a/build.gradle b/build.gradle
@@ -161,6 +161,8 @@ configure(subprojects.findAll { !sourceless.contains(it.name) && it.name != core
             apply from: rootProject.file("gradle/compile-native-multiplatform.gradle")
         }
 
+        apply from: rootProject.file("gradle/compile-jsAndWasmShared-multiplatform.gradle")
+
         apply from: rootProject.file("gradle/compile-js-multiplatform.gradle")
 
         apply from: rootProject.file("gradle/compile-wasm-multiplatform.gradle")
diff --git a/gradle/compile-js-multiplatform.gradle b/gradle/compile-js-multiplatform.gradle
@@ -13,15 +13,12 @@ kotlin {
 
     sourceSets {
         jsMain {
-            kotlin {
-                srcDir 'jsAndWasmShared/src'
-            }
+            dependsOn(jsAndWasmSharedMain)
         }
         jsTest {
-            kotlin {
-                srcDir 'jsAndWasmShared/test'
-            }
+            dependsOn(jsAndWasmSharedTest)
         }
+
         jsTest.dependencies {
             api "org.jetbrains.kotlin:kotlin-test-js:$kotlin_version"
         }
diff --git a/gradle/compile-jsAndWasmShared-multiplatform.gradle b/gradle/compile-jsAndWasmShared-multiplatform.gradle
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2016-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+kotlin {
+    sourceSets {
+        jsAndWasmSharedMain {
+            dependsOn(commonMain)
+        }
+        jsAndWasmSharedTest {
+            dependsOn(commonTest)
+        }
+    }
+}
+
+// Disable intermediate sourceSet compilation because we do not need js-wasmJs artifact
+tasks.configureEach {
+    if (name == 'compileJsAndWasmSharedMainKotlinMetadata') {
+        enabled = false
+    }
+}
diff --git a/gradle/compile-wasm-multiplatform.gradle b/gradle/compile-wasm-multiplatform.gradle
@@ -13,15 +13,12 @@ kotlin {
 
     sourceSets {
         wasmJsMain {
-            kotlin {
-                srcDir 'jsAndWasmShared/src'
-            }
+            dependsOn(jsAndWasmSharedMain)
         }
         wasmJsTest {
-            kotlin {
-                srcDir 'jsAndWasmShared/test'
-            }
+            dependsOn(jsAndWasmSharedTest)
         }
+
         wasmJsTest.dependencies {
             api "org.jetbrains.kotlin:kotlin-test-wasm-js:$kotlin_version"
         }
diff --git a/kotlinx-coroutines-core/build.gradle b/kotlinx-coroutines-core/build.gradle
@@ -15,6 +15,8 @@ if (rootProject.ext.native_targets_enabled) {
     apply from: rootProject.file("gradle/compile-native-multiplatform.gradle")
 }
 
+apply from: rootProject.file("gradle/compile-jsAndWasmShared-multiplatform.gradle")
+
 apply from: rootProject.file("gradle/compile-js-multiplatform.gradle")
 
 apply from: rootProject.file("gradle/compile-wasm-multiplatform.gradle")
@@ -26,11 +28,8 @@ apply from: rootProject.file('gradle/publish.gradle')
 
      TARGETS                            SOURCE SETS
      -------         ----------------------------------------------
-     wasmJs -------------------------------------------------+
-                                                             |
-                                                             |
-     js -----------------------------------------------------+
-                                                             |
+     wasmJs \----------> jsAndWasmShared --------------------+
+     js     /                                                |
                                                              V
      jvmCore\ --------> jvm ---------> concurrent -------> common
      jdk8   /                           ^
@@ -237,7 +236,7 @@ kotlin.sourceSets {
 
 kotlin.sourceSets.configureEach {
     // Do not apply 'ExperimentalForeignApi' where we have allWarningsAsErrors set
-    if (it.name in ["jvmMain", "jvmCoreMain", "jsMain", "concurrentMain", "commonMain"]) return
+    if (it.name in ["jvmMain", "jvmCoreMain", "jsMain", 'wasmJsMain', 'jsAndWasmSharedMain', "concurrentMain", "commonMain"]) return
     languageSettings {
         optIn('kotlinx.cinterop.ExperimentalForeignApi')
         optIn('kotlin.experimental.ExperimentalNativeApi')
@@ -380,4 +379,4 @@ task testsJar(type: Jar, dependsOn: jvmTestClasses) {
 
 artifacts {
     archives testsJar
-}
+}
diff --git a/kotlinx-coroutines-core/js/src/CoroutineContext.kt b/kotlinx-coroutines-core/js/src/CoroutineContext.kt
@@ -12,7 +12,7 @@ private external val navigator: dynamic
 private const val UNDEFINED = "undefined"
 internal external val process: dynamic
 
-internal fun createDefaultDispatcher(): CoroutineDispatcher = when {
+internal actual fun createDefaultDispatcher(): CoroutineDispatcher = when {
     // Check if we are running under jsdom. WindowDispatcher doesn't work under jsdom because it accesses MessageEvent#source.
     // It is not implemented in jsdom, see https://github.com/jsdom/jsdom/blob/master/Changelog.md
     // "It's missing a few semantics, especially around origins, as well as MessageEvent source."
diff --git a/kotlinx-coroutines-core/js/src/JSDispatcher.kt b/kotlinx-coroutines-core/js/src/JSDispatcher.kt
@@ -7,16 +7,35 @@ package kotlinx.coroutines
 import org.w3c.dom.*
 import kotlin.js.Promise
 
-internal class ScheduledMessageQueue(private val dispatcher: SetTimeoutBasedDispatcher) : MessageQueue() {
-    val processQueue: dynamic = { process() }
+@AllowDifferentMembersInActual
+public actual typealias W3CWindow = Window
 
-    override fun schedule() {
+internal actual fun w3cSetTimeout(window: W3CWindow, handler: () -> Unit, timeout: Int): Int =
+    setTimeout(window, handler, timeout)
+
+internal actual fun w3cSetTimeout(handler: () -> Unit, timeout: Int): Int =
+    setTimeout(handler, timeout)
+
+internal actual fun w3cClearTimeout(window: W3CWindow, handle: Int) =
+    window.clearTimeout(handle)
+
+internal actual fun w3cClearTimeout(handle: Int) =
+    clearTimeout(handle)
+
+internal actual class ScheduledMessageQueue actual constructor(private val dispatcher: SetTimeoutBasedDispatcher) : MessageQueue() {
+    internal val processQueue: dynamic = { process() }
+
+    actual override fun schedule() {
         dispatcher.scheduleQueueProcessing()
     }
 
-    override fun reschedule() {
+    actual override fun reschedule() {
         setTimeout(processQueue, 0)
     }
+
+    internal actual fun setTimeout(timeout: Int) {
+        setTimeout(processQueue, timeout)
+    }
 }
 
 internal object NodeDispatcher : SetTimeoutBasedDispatcher() {
@@ -25,7 +44,7 @@ internal object NodeDispatcher : SetTimeoutBasedDispatcher() {
     }
 }
 
-internal class WindowMessageQueue(private val window: Window) : MessageQueue() {
+internal actual class WindowMessageQueue actual constructor(private val window: W3CWindow) : MessageQueue() {
     private val messageName = "dispatchCoroutine"
 
     init {
@@ -37,18 +56,20 @@ internal class WindowMessageQueue(private val window: Window) : MessageQueue() {
         }, true)
     }
 
-    override fun schedule() {
+    actual override fun schedule() {
         Promise.resolve(Unit).then({ process() })
     }
 
-    override fun reschedule() {
+    actual override fun reschedule() {
         window.postMessage(messageName, "*")
     }
 }
 
 // We need to reference global setTimeout and clearTimeout so that it works on Node.JS as opposed to
 // using them via "window" (which only works in browser)
-internal external fun setTimeout(handler: dynamic, timeout: Int = definedExternally): Int
-internal external fun clearTimeout(handle: Int = definedExternally)
-internal fun setTimeout(window: WindowOrWorkerGlobalScope, handler: () -> Unit, timeout: Int): Int =
-    window.setTimeout(handler, timeout)
+private external fun setTimeout(handler: dynamic, timeout: Int = definedExternally): Int
+
+private external fun clearTimeout(handle: Int = definedExternally)
+
+private fun setTimeout(window: Window, handler: () -> Unit, timeout: Int): Int =
+    window.setTimeout(handler, timeout)
diff --git a/kotlinx-coroutines-core/js/src/internal/CoroutineExceptionHandlerImpl.kt b/kotlinx-coroutines-core/js/src/internal/CoroutineExceptionHandlerImpl.kt
@@ -0,0 +1,12 @@
+/*
+ * Copyright 2016-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.internal
+
+import kotlinx.coroutines.*
+
+internal actual fun propagateExceptionFinalResort(exception: Throwable) {
+    // log exception
+    console.error(exception.toString())
+}
diff --git a/kotlinx-coroutines-core/jsAndWasmShared/src/Dispatchers.kt b/kotlinx-coroutines-core/jsAndWasmShared/src/Dispatchers.kt
@@ -6,6 +6,8 @@ package kotlinx.coroutines
 
 import kotlin.coroutines.*
 
+internal expect fun createDefaultDispatcher(): CoroutineDispatcher
+
 public actual object Dispatchers {
     public actual val Default: CoroutineDispatcher = createDefaultDispatcher()
     public actual val Main: MainCoroutineDispatcher
diff --git a/kotlinx-coroutines-core/jsAndWasmShared/src/internal/CoroutineExceptionHandlerImpl.kt b/kotlinx-coroutines-core/jsAndWasmShared/src/internal/CoroutineExceptionHandlerImpl.kt
@@ -16,11 +16,6 @@ internal actual fun ensurePlatformExceptionHandlerLoaded(callback: CoroutineExce
     platformExceptionHandlers_ += callback
 }
 
-internal actual fun propagateExceptionFinalResort(exception: Throwable) {
-    // log exception
-    console.error(exception.toString())
-}
-
 internal actual class DiagnosticCoroutineContextException actual constructor(context: CoroutineContext) :
     RuntimeException(context.toString())
 
diff --git a/kotlinx-coroutines-core/jsAndWasmShared/src/internal/JSDispatcher.kt b/kotlinx-coroutines-core/jsAndWasmShared/src/internal/JSDispatcher.kt
@@ -5,16 +5,32 @@
 package kotlinx.coroutines
 
 import kotlinx.coroutines.internal.*
-import org.w3c.dom.*
 import kotlin.coroutines.*
 
+public expect abstract class W3CWindow
+internal expect fun w3cSetTimeout(window: W3CWindow, handler: () -> Unit, timeout: Int): Int
+internal expect fun w3cSetTimeout(handler: () -> Unit, timeout: Int): Int
+internal expect fun w3cClearTimeout(handle: Int)
+internal expect fun w3cClearTimeout(window: W3CWindow, handle: Int)
+
+internal expect class ScheduledMessageQueue(dispatcher: SetTimeoutBasedDispatcher) : MessageQueue {
+    override fun schedule()
+    override fun reschedule()
+    internal fun setTimeout(timeout: Int)
+}
+
+internal expect class WindowMessageQueue(window: W3CWindow) : MessageQueue {
+    override fun schedule()
+    override fun reschedule()
+}
+
 private const val MAX_DELAY = Int.MAX_VALUE.toLong()
 
 private fun delayToInt(timeMillis: Long): Int =
     timeMillis.coerceIn(0, MAX_DELAY).toInt()
 
-internal sealed class SetTimeoutBasedDispatcher: CoroutineDispatcher(), Delay {
-    val messageQueue = ScheduledMessageQueue(this)
+internal abstract class SetTimeoutBasedDispatcher: CoroutineDispatcher(), Delay {
+    internal val messageQueue = ScheduledMessageQueue(this)
 
     abstract fun scheduleQueueProcessing()
 
@@ -28,48 +44,47 @@ internal sealed class SetTimeoutBasedDispatcher: CoroutineDispatcher(), Delay {
     }
 
     override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
-        val handle = setTimeout({ block.run() }, delayToInt(timeMillis))
+        val handle = w3cSetTimeout({ block.run() }, delayToInt(timeMillis))
         return ClearTimeout(handle)
     }
 
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
-        val handle = setTimeout({ with(continuation) { resumeUndispatched(Unit) } }, delayToInt(timeMillis))
+        val handle = w3cSetTimeout({ with(continuation) { resumeUndispatched(Unit) } }, delayToInt(timeMillis))
         continuation.invokeOnCancellation(handler = ClearTimeout(handle).asHandler)
     }
 }
 
-internal class WindowDispatcher(private val window: Window) : CoroutineDispatcher(), Delay {
+internal class WindowDispatcher(private val window: W3CWindow) : CoroutineDispatcher(), Delay {
     private val queue = WindowMessageQueue(window)
 
     override fun dispatch(context: CoroutineContext, block: Runnable) = queue.enqueue(block)
 
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
-        val handle = setTimeout(window, { with(continuation) { resumeUndispatched(Unit) } }, delayToInt(timeMillis))
+        val handle = w3cSetTimeout(window, { with(continuation) { resumeUndispatched(Unit) } }, delayToInt(timeMillis))
         continuation.invokeOnCancellation(handler = WindowClearTimeout(handle).asHandler)
     }
 
     override fun invokeOnTimeout(timeMillis: Long, block: Runnable, context: CoroutineContext): DisposableHandle {
-        val handle = setTimeout(window, block::run, delayToInt(timeMillis))
+        val handle = w3cSetTimeout(window, block::run, delayToInt(timeMillis))
         return WindowClearTimeout(handle)
     }
 
     private inner class WindowClearTimeout(handle: Int) : ClearTimeout(handle) {
         override fun dispose() {
-            window.clearTimeout(handle)
+            w3cClearTimeout(window, handle)
         }
     }
 }
 
 internal object SetTimeoutDispatcher : SetTimeoutBasedDispatcher() {
     override fun scheduleQueueProcessing() {
-        setTimeout(messageQueue.processQueue, 0)
+        messageQueue.setTimeout(0)
     }
 }
 
 private open class ClearTimeout(protected val handle: Int) : CancelHandler(), DisposableHandle {
-
     override fun dispose() {
-        clearTimeout(handle)
+        w3cClearTimeout(handle)
     }
 
     override fun invoke(cause: Throwable?) {
diff --git a/kotlinx-coroutines-core/wasmJs/src/CoroutineContext.kt b/kotlinx-coroutines-core/wasmJs/src/CoroutineContext.kt
@@ -18,7 +18,7 @@ internal fun tryGetProcess(): JsProcess? =
 internal fun tryGetWindow(): Window? =
     js("(typeof(window) !== 'undefined' && window != null && typeof(window.addEventListener) === 'function') ? window : null")
 
-internal fun createDefaultDispatcher(): CoroutineDispatcher =
+internal actual fun createDefaultDispatcher(): CoroutineDispatcher =
     tryGetProcess()?.let(::NodeDispatcher)
         ?: tryGetWindow()?.let(::WindowDispatcher)
         ?: SetTimeoutDispatcher
diff --git a/kotlinx-coroutines-core/wasmJs/src/JSDispatcher.kt b/kotlinx-coroutines-core/wasmJs/src/JSDispatcher.kt
diff --git a/kotlinx-coroutines-core/wasmJs/src/internal/CoroutineExceptionHandlerImpl.kt b/kotlinx-coroutines-core/wasmJs/src/internal/CoroutineExceptionHandlerImpl.kt

Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,8 @@ configure(subprojects.findAll { !sourceless.contains(it.name) && it.name != core`
`161`	`161`	`apply from: rootProject.file("gradle/compile-native-multiplatform.gradle")`
`162`	`162`	`}`
`163`	`163`
	`164`	`+ apply from: rootProject.file("gradle/compile-jsAndWasmShared-multiplatform.gradle")`
	`165`	`+`
`164`	`166`	`apply from: rootProject.file("gradle/compile-js-multiplatform.gradle")`
`165`	`167`
`166`	`168`	`apply from: rootProject.file("gradle/compile-wasm-multiplatform.gradle")`
Original file line number	Diff line number	Diff line change
`@@ -13,15 +13,12 @@ kotlin {`
`13`	`13`
`14`	`14`	`sourceSets {`
`15`	`15`	`jsMain {`
`16`		`- kotlin {`
`17`		`- srcDir 'jsAndWasmShared/src'`
`18`		`- }`
	`16`	`+ dependsOn(jsAndWasmSharedMain)`
`19`	`17`	`}`
`20`	`18`	`jsTest {`
`21`		`- kotlin {`
`22`		`- srcDir 'jsAndWasmShared/test'`
`23`		`- }`
	`19`	`+ dependsOn(jsAndWasmSharedTest)`
`24`	`20`	`}`
	`21`	`+`
`25`	`22`	`jsTest.dependencies {`
`26`	`23`	`api "org.jetbrains.kotlin:kotlin-test-js:$kotlin_version"`
`27`	`24`	`}`