Minimize cut-and-pasted code between JS and JVM

Author: elizarov

core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/AbstractContinuation.kt renamed to common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/AbstractContinuation.kt

@@ -16,10 +16,9 @@
 
 package kotlinx.coroutines.experimental
 
-import kotlinx.atomicfu.atomic
-import kotlinx.atomicfu.loop
-import kotlin.coroutines.experimental.Continuation
-import kotlin.coroutines.experimental.intrinsics.COROUTINE_SUSPENDED
+import kotlinx.atomicfu.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
 
 private const val UNDECIDED = 0
 private const val SUSPENDED = 1

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2016-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// NOTE: We are defining them in a special internalAnnotations package because they would break
+// user code that uses kotlinx.coroutines library otherwise, see https://youtrack.jetbrains.com/issue/KT-23727
+package kotlinx.coroutines.experimental.internalAnnotations
+
+@Target(AnnotationTarget.FILE)
+internal expect annotation class JvmName(val name: String)
+
+@Target(AnnotationTarget.FILE)
+internal expect annotation class JvmMultifileClass()
+
+internal expect annotation class JvmField()
+
+internal expect annotation class Volatile()

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/Builders.kt renamed to common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/Builders.common.kt

@@ -14,15 +14,18 @@
  * limitations under the License.
  */
 
-// :todo: Remove after transition to Kotlin 1.2.30+
-@file:Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
+@file:JvmMultifileClass
+@file:JvmName("BuildersKt")
 
 package kotlinx.coroutines.experimental
 
+import kotlinx.coroutines.experimental.internalAnnotations.*
 import kotlinx.coroutines.experimental.intrinsics.*
 import kotlin.coroutines.experimental.*
 import kotlin.coroutines.experimental.intrinsics.*
 
+// --------------- basic coroutine builders ---------------
+
 /**
  * Launches new coroutine without blocking current thread and returns a reference to the coroutine as a [Job].
  * The coroutine is cancelled when the resulting job is [cancelled][Job.cancel].
@@ -54,7 +57,7 @@ import kotlin.coroutines.experimental.intrinsics.*
  * @param onCompletion optional completion handler for the coroutine (see [Job.invokeOnCompletion]).
  * @param block the coroutine code.
  */
-public actual fun launch(
+public fun launch(
     context: CoroutineContext = DefaultDispatcher,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     parent: Job? = null,
@@ -69,6 +72,31 @@ public actual fun launch(
     coroutine.start(start, coroutine, block)
     return coroutine
 }
+/** @suppress **Deprecated**: Binary compatibility */
+@Deprecated(message = "Binary compatibility", level = DeprecationLevel.HIDDEN)
+public fun launch(
+    context: CoroutineContext = DefaultDispatcher,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    parent: Job? = null,
+    block: suspend CoroutineScope.() -> Unit
+): Job = launch(context, start, parent, block = block)
+
+/** @suppress **Deprecated**: Binary compatibility */
+@Deprecated(message = "Binary compatibility", level = DeprecationLevel.HIDDEN)
+public fun launch(
+    context: CoroutineContext = DefaultDispatcher,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> Unit
+): Job =
+    launch(context, start, block = block)
+
+/**
+ * @suppress **Deprecated**: Use `start = CoroutineStart.XXX` parameter
+ */
+@Deprecated(message = "Use `start = CoroutineStart.XXX` parameter",
+    replaceWith = ReplaceWith("launch(context, if (start) CoroutineStart.DEFAULT else CoroutineStart.LAZY, block)"))
+public fun launch(context: CoroutineContext, start: Boolean, block: suspend CoroutineScope.() -> Unit): Job =
+    launch(context, if (start) CoroutineStart.DEFAULT else CoroutineStart.LAZY, block = block)
 
 /**
  * Calls the specified suspending block with a given coroutine context, suspends until it completes, and returns
@@ -86,7 +114,7 @@ public actual fun launch(
  * Other options can be specified via `start` parameter. See [CoroutineStart] for details.
  * A value of [CoroutineStart.LAZY] is not supported and produces [IllegalArgumentException].
  */
-public actual suspend fun <T> withContext(
+public suspend fun <T> withContext(
     context: CoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     block: suspend () -> T
@@ -111,17 +139,34 @@ public actual suspend fun <T> withContext(
     val completion = RunCompletion(
         context = newContext,
         delegate = cont,
-        resumeMode = if (start == CoroutineStart.ATOMIC) MODE_ATOMIC_DEFAULT else MODE_CANCELLABLE)
+        resumeMode = if (start == CoroutineStart.ATOMIC) MODE_ATOMIC_DEFAULT else MODE_CANCELLABLE
+    )
     completion.initParentJobInternal(newContext[Job]) // attach to job
+    @Suppress("DEPRECATION")
     start(block, completion)
     completion.getResult()
 }
 
+/** @suppress **Deprecated**: Renamed to [withContext]. */
+@Deprecated(message = "Renamed to `withContext`", level=DeprecationLevel.WARNING,
+    replaceWith = ReplaceWith("withContext(context, start, block)"))
+public suspend fun <T> run(
+    context: CoroutineContext,
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend () -> T
+): T =
+    withContext(context, start, block)
+
+/** @suppress **Deprecated** */
+@Deprecated(message = "It is here for binary compatibility only", level=DeprecationLevel.HIDDEN)
+public suspend fun <T> run(context: CoroutineContext, block: suspend () -> T): T =
+    withContext(context, start = CoroutineStart.ATOMIC, block = block)
+
 // --------------- implementation ---------------
 
 private open class StandaloneCoroutine(
-        private val parentContext: CoroutineContext,
-        active: Boolean
+    private val parentContext: CoroutineContext,
+    active: Boolean
 ) : AbstractCoroutine<Unit>(parentContext, active) {
     override fun hasOnFinishingHandler(update: Any?) = update is CompletedExceptionally
     override fun onFinishingInternal(update: Any?) {
@@ -131,8 +176,8 @@ private open class StandaloneCoroutine(
 }
 
 private class LazyStandaloneCoroutine(
-        parentContext: CoroutineContext,
-        private val block: suspend CoroutineScope.() -> Unit
+    parentContext: CoroutineContext,
+    private val block: suspend CoroutineScope.() -> Unit
 ) : StandaloneCoroutine(parentContext, active = false) {
     override fun onStart() {
         block.startCoroutineCancellable(this, this)
@@ -144,12 +189,9 @@ private class RunContinuationDirect<in T>(
     continuation: Continuation<T>
 ) : Continuation<T> by continuation
 
-
 @Suppress("UNCHECKED_CAST")
 private class RunCompletion<in T>(
     override val context: CoroutineContext,
     delegate: Continuation<T>,
     resumeMode: Int
 ) : AbstractContinuation<T>(delegate, resumeMode)
-
-

core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt renamed to common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt

@@ -14,16 +14,12 @@
  * limitations under the License.
  */
 
-// :todo: Remove after transition to Kotlin 1.2.30+
-@file:Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
-
 package kotlinx.coroutines.experimental
 
-import kotlinx.coroutines.experimental.internal.LockFreeLinkedListNode
-import kotlin.coroutines.experimental.Continuation
-import kotlin.coroutines.experimental.CoroutineContext
-import kotlin.coroutines.experimental.intrinsics.suspendCoroutineOrReturn
-import kotlin.coroutines.experimental.suspendCoroutine
+import kotlinx.coroutines.experimental.internal.*
+import kotlinx.coroutines.experimental.internalAnnotations.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
 
 // --------------- cancellable continuations ---------------
 
@@ -61,24 +57,24 @@ import kotlin.coroutines.experimental.suspendCoroutine
  *
  * ```
  */
-public actual interface CancellableContinuation<in T> : Continuation<T>, Job {
+public interface CancellableContinuation<in T> : Continuation<T>, Job {
     /**
      * Returns `true` when this continuation is active -- it has not completed or cancelled yet.
      */
-    public actual override val isActive: Boolean
+    public override val isActive: Boolean
 
     /**
      * Returns `true` when this continuation has completed for any reason. A continuation
      * that was cancelled is also considered complete.
      */
-    public actual override val isCompleted: Boolean
+    public override val isCompleted: Boolean
 
     /**
      * Returns `true` if this continuation was [cancelled][cancel].
      *
      * It implies that [isActive] is `false` and [isCompleted] is `true`.
      */
-    public actual override val isCancelled: Boolean
+    public override val isCancelled: Boolean
 
     /**
      * Tries to resume this continuation with a given value and returns non-null object token if it was successful,
@@ -90,7 +86,7 @@ public actual interface CancellableContinuation<in T> : Continuation<T>, Job {
      *
      * @suppress **This is unstable API and it is subject to change.**
      */
-    public actual fun tryResume(value: T, idempotent: Any? = null): Any?
+    public fun tryResume(value: T, idempotent: Any? = null): Any?
 
     /**
      * Tries to resume this continuation with a given exception and returns non-null object token if it was successful,
@@ -106,20 +102,20 @@ public actual interface CancellableContinuation<in T> : Continuation<T>, Job {
      *
      * @suppress **This is unstable API and it is subject to change.**
      */
-    public actual fun completeResume(token: Any)
+    public fun completeResume(token: Any)
 
     /**
      * Makes this continuation cancellable. Use it with `holdCancellability` optional parameter to
      * [suspendCancellableCoroutine] function. It throws [IllegalStateException] if invoked more than once.
      */
-    public actual fun initCancellability()
+    public fun initCancellability()
 
     /**
      * Cancels this continuation with an optional cancellation [cause]. The result is `true` if this continuation was
      * cancelled as a result of this invocation and `false` otherwise.
      */
     @Suppress("DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE")
-    public actual override fun cancel(cause: Throwable? = null): Boolean
+    public override fun cancel(cause: Throwable? = null): Boolean
 
     /**
      * Registers handler that is **synchronously** invoked once on completion of this continuation.
@@ -135,23 +131,23 @@ public actual interface CancellableContinuation<in T> : Continuation<T>, Job {
      * 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.
      */
-    public actual override fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
+    public override fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle
 
     /**
      * Resumes this continuation with a given [value] in the invoker thread without going though
      * [dispatch][CoroutineDispatcher.dispatch] function of the [CoroutineDispatcher] in the [context].
      * This function is designed to be used only by the [CoroutineDispatcher] implementations themselves.
      * **It should not be used in general code**.
      */
-    public actual fun CoroutineDispatcher.resumeUndispatched(value: T)
+    public fun CoroutineDispatcher.resumeUndispatched(value: T)
 
     /**
      * Resumes this continuation with a given [exception] in the invoker thread without going though
      * [dispatch][CoroutineDispatcher.dispatch] function of the [CoroutineDispatcher] in the [context].
      * This function is designed to be used only by the [CoroutineDispatcher] implementations themselves.
      * **It should not be used in general code**.
      */
-    public actual fun CoroutineDispatcher.resumeUndispatchedWithException(exception: Throwable)
+    public fun CoroutineDispatcher.resumeUndispatchedWithException(exception: Throwable)
 }
 
 /**
@@ -163,7 +159,7 @@ public actual interface CancellableContinuation<in T> : Continuation<T>, Job {
  *
  * See [suspendAtomicCancellableCoroutine] for suspending functions that need *atomic cancellation*.
  */
-public actual inline suspend fun <T> suspendCancellableCoroutine(
+public suspend inline fun <T> suspendCancellableCoroutine(
     holdCancellability: Boolean = false,
     crossinline block: (CancellableContinuation<T>) -> Unit
 ): T =
@@ -172,7 +168,7 @@ public actual inline suspend fun <T> suspendCancellableCoroutine(
         if (!holdCancellability) cancellable.initCancellability()
         block(cancellable)
         cancellable.getResult()
-}
+    }
 
 /**
  * Suspends coroutine similar to [suspendCancellableCoroutine], but with *atomic cancellation*.
@@ -182,7 +178,7 @@ public actual inline suspend fun <T> suspendCancellableCoroutine(
  * continue to execute even after it was cancelled from the same thread in the case when the continuation
  * was already resumed and was posted for execution to the thread's queue.
  */
-public actual inline suspend fun <T> suspendAtomicCancellableCoroutine(
+public suspend inline fun <T> suspendAtomicCancellableCoroutine(
     holdCancellability: Boolean = false,
     crossinline block: (CancellableContinuation<T>) -> Unit
 ): T =
@@ -198,15 +194,15 @@ public actual inline suspend fun <T> suspendAtomicCancellableCoroutine(
  * @suppress **This is unstable API and it is subject to change.**
  */
 public fun CancellableContinuation<*>.removeOnCancel(node: LockFreeLinkedListNode): DisposableHandle =
-    invokeOnCompletion(handler = RemoveOnCancel(this, node))
+    invokeOnCompletion(handler = RemoveOnCancel(this, node).asHandler)
 
 // --------------- implementation details ---------------
 
 private class RemoveOnCancel(
     cont: CancellableContinuation<*>,
-    val node: LockFreeLinkedListNode
+    @JvmField val node: LockFreeLinkedListNode
 ) : JobNode<CancellableContinuation<*>>(cont)  {
-    override fun invoke(reason: Throwable?) {
+    override fun invoke(cause: Throwable?) {
         if (job.isCancelled)
             node.remove()
     }
@@ -283,12 +279,16 @@ internal class CancellableContinuationImpl<in T>(
 
     override fun nameString(): String =
         "CancellableContinuation(${delegate.toDebugString()})"
+
+    // todo: This workaround for KT-21968, should be removed in the future
+    public override fun cancel(cause: Throwable?): Boolean =
+        super.cancel(cause)
 }
 
 private class CompletedIdempotentResult(
     @JvmField val idempotentResume: Any?,
     @JvmField val result: Any?,
-    @JvmField val token: JobSupport.Incomplete
+    @JvmField val token: Incomplete
 ) {
     override fun toString(): String = "CompletedIdempotentResult[$result]"
 }