MPP: Job/launch and related basic interface are extracted; JS basic impl

Author: elizarov

build.gradle

@@ -51,16 +51,30 @@ def pomConfig = {
 
 def sourceless = ['site']
 
+static def platformOf(project) {
+    if (project.name.endsWith("-common")) return "common"
+    if (project.name.endsWith("-js")) return "js"
+    return "jvm"
+}
+
+static def platformLib(base, platform) {
+    if (platform == "jvm") return base
+    return "$base-$platform"
+}
+
 configure(subprojects.findAll { !sourceless.contains(it.name)  }) {
-    apply plugin: 'kotlin'
+    def platform = platformOf(it)
+    apply plugin: "kotlin-platform-$platform"
+
+    if (platform == "jvm") {
+        sourceCompatibility = 1.6
+        targetCompatibility = 1.6
 
-    sourceCompatibility = 1.6
-    targetCompatibility = 1.6
-    
-    tasks.withType(JavaCompile) {
-        options.encoding = 'UTF-8'
+        tasks.withType(JavaCompile) {
+            options.encoding = 'UTF-8'
+        }
     }
-    
+
     kotlin.experimental.coroutines "enable"
 
     tasks.withType(Test) {
@@ -75,8 +89,10 @@ configure(subprojects.findAll { !sourceless.contains(it.name)  }) {
         maven { url "https://dl.bintray.com/devexperts/Maven/" }
     }
 
+    def kotlin_stdlib = platformLib("kotlin-stdlib", platform)
+
     dependencies {
-        compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+        compile "org.jetbrains.kotlin:$kotlin_stdlib:$kotlin_version"
         testCompile "junit:junit:$junit_version"
     }
 }
@@ -85,7 +101,8 @@ configure(subprojects.findAll { !sourceless.contains(it.name)  }) {
 
 def internal = sourceless + ['benchmarks', 'knit']
 
-configure(subprojects.findAll { !internal.contains(it.name) }) {
+// configure atomicfu for JVM modules
+configure(subprojects.findAll { !internal.contains(it.name) && platformOf(it) == "jvm" }) {
     apply plugin: 'kotlinx-atomicfu'
 
     dependencies {
@@ -110,11 +127,21 @@ configure(subprojects.findAll { !internal.contains(it.name) }) {
     }
 }
 
-configure(subprojects.findAll { !internal.contains(it.name) && it.name != 'kotlinx-coroutines-core'}) {
-    dependencies {
-        compile project(':kotlinx-coroutines-core')
-        //the only way IDEA can resolve test classes
-        testCompile project(':kotlinx-coroutines-core').sourceSets.test.output
+// configure dependencies on core
+configure(subprojects.findAll { !internal.contains(it.name) && it.name != 'kotlinx-coroutines-core-common'}) {
+    def platform = platformOf(it)
+    def coroutines_core = platformLib("kotlinx-coroutines-core", platform)
+
+    if (it.name == coroutines_core) {
+        dependencies {
+            expectedBy project(':kotlinx-coroutines-core-common')
+        }
+    } else {
+        dependencies {
+            compile project(":$coroutines_core")
+            //the only way IDEA can resolve test classes
+            testCompile project(":$coroutines_core").sourceSets.test.output
+        }
     }
 }
 
@@ -126,6 +153,8 @@ def core_docs_url = "https://kotlin.github.io/kotlinx.coroutines/kotlinx-corouti
 def core_docs_file = "$projectDir/core/kotlinx-coroutines-core/build/dokka/kotlinx-coroutines-core/package-list"
 
 configure(subprojects.findAll { !unpublished.contains(it.name) }) {
+    def platform = platformOf(it)
+
     apply plugin: 'maven'
     apply plugin: 'maven-publish'
     apply plugin: 'org.jetbrains.dokka'
@@ -135,9 +164,23 @@ configure(subprojects.findAll { !unpublished.contains(it.name) }) {
         outputFormat = 'kotlin-website'
     }
 
-    task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
-        outputFormat = 'javadoc'
-        outputDirectory = "$buildDir/javadoc"
+    if (platform == "jvm") {
+        // real xxx-javadoc.jar for JVM
+        task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
+            outputFormat = 'javadoc'
+            outputDirectory = "$buildDir/javadoc"
+        }
+
+        task javadocJar(type: Jar, dependsOn: dokkaJavadoc) {
+            classifier = 'javadoc'
+            from "$buildDir/javadoc"
+        }
+    } else {
+        // empty xxx-javadoc.jar
+        task javadocJar(type: Jar) {
+            classifier = 'javadoc'
+            from "$buildDir/javadoc" // would not exist
+        }
     }
 
     tasks.withType(org.jetbrains.dokka.gradle.DokkaTask) {
@@ -151,11 +194,6 @@ configure(subprojects.findAll { !unpublished.contains(it.name) }) {
         }
     }
 
-    task javadocJar(type: Jar, dependsOn: dokkaJavadoc) {
-        classifier = 'javadoc'
-        from "$buildDir/javadoc"
-    }
-
     task sourcesJar(type: Jar, dependsOn: classes) {
         classifier = 'sources'
         from sourceSets.main.allSource
@@ -199,9 +237,14 @@ configure(subprojects.findAll { !unpublished.contains(it.name) }) {
     }
 }
 
-configure(subprojects.findAll { !unpublished.contains(it.name) && it.name != 'kotlinx-coroutines-core' }) {
-    dokka.dependsOn project(':kotlinx-coroutines-core').dokka
-    dokkaJavadoc.dependsOn project(':kotlinx-coroutines-core').dokka
+configure(subprojects.findAll { !unpublished.contains(it.name) && it.name != 'kotlinx-coroutines-core-common' }) {
+    def platform = platformOf(it)
+    def coroutines_core = platformLib("kotlinx-coroutines-core", platform)
+
+    dokka.dependsOn project(":$coroutines_core").dokka
+    if (platform == "jvm") {
+        dokkaJavadoc.dependsOn project(":$coroutines_core").dokka
+    }
 
     tasks.withType(org.jetbrains.dokka.gradle.DokkaTask) {
         externalDocumentationLink {

common/kotlinx-coroutines-core-common/build.gradle

@@ -0,0 +1,11 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.CoroutineContext
+
+@Suppress("EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER")
+public expect fun launch(
+    context: CoroutineContext = DefaultDispatcher,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    block: suspend CoroutineScope.() -> Unit
+): Job

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonBuilders.kt

@@ -0,0 +1,30 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.Continuation
+
+public expect interface CancellableContinuation<in T> : Continuation<T> {
+    public val isActive: Boolean
+    public val isCompleted: Boolean
+    public val isCancelled: Boolean
+    @Suppress("EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER")
+    public fun tryResume(value: T, idempotent: Any? = null): Any?
+    public fun completeResume(token: Any)
+    public fun initCancellability()
+    @Suppress("EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER")
+    public actual fun cancel(cause: Throwable? = null): Boolean
+    public fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
+    public fun CoroutineDispatcher.resumeUndispatched(value: T)
+    public fun CoroutineDispatcher.resumeUndispatchedWithException(exception: Throwable)
+}
+
+@Suppress("EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER")
+public expect suspend fun <T> suspendCancellableCoroutine(
+    holdCancellability: Boolean = false,
+    block: (CancellableContinuation<T>) -> Unit
+): T
+
+@Suppress("EXPECTED_DECLARATION_WITH_DEFAULT_PARAMETER")
+public expect suspend fun <T> suspendAtomicCancellableCoroutine(
+    holdCancellability: Boolean = false,
+    block: (CancellableContinuation<T>) -> Unit
+): T

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonCancellableContinuation.kt

@@ -0,0 +1,14 @@
+package kotlinx.coroutines.experimental
+
+/**
+ * Handler for [Job.invokeOnCompletion].
+ *
+ * Installed handler should not throw any exceptions. If it does, they will get caught,
+ * wrapped into [CompletionHandlerException], and rethrown, potentially causing crash of unrelated code.
+ *
+ * **Note**: This type is a part of internal machinery that supports parent-child hierarchies
+ * and allows for implementation of suspending functions that wait on the Job's state.
+ * This type should not be used in general application code.
+ * Implementations of `CompletionHandler` must be fast and _lock-free_.
+ */
+public typealias CompletionHandler = (cause: Throwable?) -> Unit

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonCompletionHandler.kt

@@ -0,0 +1,8 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.CoroutineContext
+
+public expect object Unconfined : CoroutineDispatcher {
+    override fun isDispatchNeeded(context: CoroutineContext): Boolean
+    override fun dispatch(context: CoroutineContext, block: Runnable)
+}

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonCoroutineContext.kt

@@ -0,0 +1,16 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.ContinuationInterceptor
+import kotlin.coroutines.experimental.CoroutineContext
+
+public expect abstract class CoroutineDispatcher : ContinuationInterceptor {
+    public open fun isDispatchNeeded(context: CoroutineContext): Boolean
+    public abstract fun dispatch(context: CoroutineContext, block: Runnable)
+}
+
+public expect interface Runnable {
+    public fun run()
+}
+
+@Suppress("PropertyName")
+public expect val DefaultDispatcher: CoroutineDispatcher

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonCoroutineDispatcher.kt

@@ -0,0 +1,13 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.CoroutineContext
+
+public expect fun handleCoroutineException(context: CoroutineContext, exception: Throwable)
+
+public expect interface CoroutineExceptionHandler : CoroutineContext.Element {
+    public companion object Key : CoroutineContext.Key<CoroutineExceptionHandler>
+    public fun handleException(context: CoroutineContext, exception: Throwable)
+}
+
+@Suppress("FunctionName")
+public expect fun CoroutineExceptionHandler(handler: (CoroutineContext, Throwable) -> Unit): CoroutineExceptionHandler

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonCoroutineExceptionHandler.kt

@@ -0,0 +1,8 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.CoroutineContext
+
+public expect interface CoroutineScope {
+    public val isActive: Boolean
+    public val coroutineContext: CoroutineContext
+}

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonCoroutineScope.kt

@@ -0,0 +1,13 @@
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.Continuation
+
+public expect enum class CoroutineStart {
+    DEFAULT,
+    LAZY,
+    ATOMIC,
+    UNDISPATCHED;
+    public operator fun <T> invoke(block: suspend () -> T, completion: Continuation<T>)
+    public operator fun <R, T> invoke(block: suspend R.() -> T, receiver: R, completion: Continuation<T>)
+    public val isLazy: Boolean
+}