Switch sourcesets of experimental and release coroutines

- Move experimental coroutines out of the main source root.
- Include experimental coroutines into the coroutines source set.
- Include release coroutines into the main source set.

libraries/stdlib/jvm/src/generated/_SequencesJvm.kt

@@ -16,7 +16,6 @@ package kotlin.sequences
 import kotlin.*
 import kotlin.text.*
 import kotlin.comparisons.*
-import kotlin.coroutines.experimental.*
 
 /**
  * Returns a sequence containing all elements that are instances of specified class.

libraries/stdlib/jvm/src/kotlin/coroutines/experimental/SafeContinuationJvm.kt

@@ -1,81 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-package kotlin.coroutines.experimental
-
-import java.util.concurrent.atomic.AtomicReferenceFieldUpdater
-import kotlin.*
-import kotlin.coroutines.experimental.intrinsics.COROUTINE_SUSPENDED
-
-@PublishedApi
-internal actual class SafeContinuation<in T>
-internal actual constructor(
-    private val delegate: Continuation<T>,
-    initialResult: Any?
-) : Continuation<T> {
-
-    @PublishedApi
-    internal actual constructor(delegate: Continuation<T>) : this(delegate, UNDECIDED)
-
-    public actual override val context: CoroutineContext
-        get() = delegate.context
-
-    @Volatile
-    private var result: Any? = initialResult
-
-    companion object {
-        private val UNDECIDED: Any? = Any()
-        private val RESUMED: Any? = Any()
-
-        @Suppress("UNCHECKED_CAST")
-        @JvmStatic
-        private val RESULT = AtomicReferenceFieldUpdater.newUpdater<SafeContinuation<*>, Any?>(
-            SafeContinuation::class.java, Any::class.java as Class<Any?>, "result"
-        )
-    }
-
-    private class Fail(val exception: Throwable)
-
-    actual override fun resume(value: T) {
-        while (true) { // lock-free loop
-            val result = this.result // atomic read
-            when {
-                result === UNDECIDED -> if (RESULT.compareAndSet(this, UNDECIDED, value)) return
-                result === COROUTINE_SUSPENDED -> if (RESULT.compareAndSet(this, COROUTINE_SUSPENDED, RESUMED)) {
-                    delegate.resume(value)
-                    return
-                }
-                else -> throw IllegalStateException("Already resumed")
-            }
-        }
-    }
-
-    actual override fun resumeWithException(exception: Throwable) {
-        while (true) { // lock-free loop
-            val result = this.result // atomic read
-            when {
-                result === UNDECIDED -> if (RESULT.compareAndSet(this, UNDECIDED, Fail(exception))) return
-                result === COROUTINE_SUSPENDED -> if (RESULT.compareAndSet(this, COROUTINE_SUSPENDED, RESUMED)) {
-                    delegate.resumeWithException(exception)
-                    return
-                }
-                else -> throw IllegalStateException("Already resumed")
-            }
-        }
-    }
-
-    @PublishedApi
-    internal actual fun getResult(): Any? {
-        var result = this.result // atomic read
-        if (result === UNDECIDED) {
-            if (RESULT.compareAndSet(this, UNDECIDED, COROUTINE_SUSPENDED)) return COROUTINE_SUSPENDED
-            result = this.result // reread volatile var
-        }
-        when {
-            result === RESUMED -> return COROUTINE_SUSPENDED // already called continuation, indicate COROUTINE_SUSPENDED upstream
-            result is Fail -> throw result.exception
-            else -> return result // either COROUTINE_SUSPENDED or data
-        }
-    }
-}

libraries/stdlib/jvm/src/kotlin/coroutines/experimental/intrinsics/IntrinsicsJvm.kt

@@ -1,125 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-@file:kotlin.jvm.JvmName("IntrinsicsKt")
-@file:kotlin.jvm.JvmMultifileClass
-
-package kotlin.coroutines.experimental.intrinsics
-
-import kotlin.coroutines.experimental.*
-
-/**
- * Starts unintercepted coroutine without receiver and with result type [T] and executes it until its first suspension.
- * Returns the result of the coroutine or throws its exception if it does not suspend or [COROUTINE_SUSPENDED] if it suspends.
- * In the later case, the [completion] continuation is invoked when coroutine completes with result or exception.
- * This function is designed to be used from inside of [suspendCoroutineOrReturn] to resume the execution of suspended
- * coroutine using a reference to the suspending function.
- */
-@SinceKotlin("1.1")
-@Suppress("UNCHECKED_CAST")
-@kotlin.internal.InlineOnly
-public actual inline fun <T> (suspend () -> T).startCoroutineUninterceptedOrReturn(
-    completion: Continuation<T>
-): Any? = (this as Function1<Continuation<T>, Any?>).invoke(completion)
-
-/**
- * Starts unintercepted coroutine with receiver type [R] and result type [T] and executes it until its first suspension.
- * Returns the result of the coroutine or throws its exception if it does not suspend or [COROUTINE_SUSPENDED] if it suspends.
- * In the later case, the [completion] continuation is invoked when coroutine completes with result or exception.
- * This function is designed to be used from inside of [suspendCoroutineOrReturn] to resume the execution of suspended
- * coroutine using a reference to the suspending function.
- */
-@SinceKotlin("1.1")
-@Suppress("UNCHECKED_CAST")
-@kotlin.internal.InlineOnly
-public actual inline fun <R, T> (suspend R.() -> T).startCoroutineUninterceptedOrReturn(
-    receiver: R,
-    completion: Continuation<T>
-): Any? = (this as Function2<R, Continuation<T>, Any?>).invoke(receiver, completion)
-
-
-// JVM declarations
-
-/**
- * Creates a coroutine without receiver and with result type [T].
- * This function creates a new, fresh instance of suspendable computation every time it is invoked.
- *
- * To start executing the created coroutine, invoke `resume(Unit)` on the returned [Continuation] instance.
- * The [completion] continuation is invoked when coroutine completes with result or exception.
- *
- * This function is _unchecked_. Repeated invocation of any resume function on the resulting continuation corrupts the
- * state machine of the coroutine and may result in arbitrary behaviour or exception.
- */
-@SinceKotlin("1.1")
-public actual fun <T> (suspend () -> T).createCoroutineUnchecked(
-    completion: Continuation<T>
-): Continuation<Unit> =
-    if (this !is kotlin.coroutines.experimental.jvm.internal.CoroutineImpl)
-        buildContinuationByInvokeCall(completion) {
-            @Suppress("UNCHECKED_CAST")
-            (this as Function1<Continuation<T>, Any?>).invoke(completion)
-        }
-    else
-        (this.create(completion) as kotlin.coroutines.experimental.jvm.internal.CoroutineImpl).facade
-
-/**
- * Creates a coroutine with receiver type [R] and result type [T].
- * This function creates a new, fresh instance of suspendable computation every time it is invoked.
- *
- * To start executing the created coroutine, invoke `resume(Unit)` on the returned [Continuation] instance.
- * The [completion] continuation is invoked when coroutine completes with result or exception.
- *
- * This function is _unchecked_. Repeated invocation of any resume function on the resulting continuation corrupts the
- * state machine of the coroutine and may result in arbitrary behaviour or exception.
- */
-@SinceKotlin("1.1")
-public actual fun <R, T> (suspend R.() -> T).createCoroutineUnchecked(
-    receiver: R,
-    completion: Continuation<T>
-): Continuation<Unit> =
-    if (this !is kotlin.coroutines.experimental.jvm.internal.CoroutineImpl)
-        buildContinuationByInvokeCall(completion) {
-            @Suppress("UNCHECKED_CAST")
-            (this as Function2<R, Continuation<T>, Any?>).invoke(receiver, completion)
-        }
-    else
-        (this.create(receiver, completion) as kotlin.coroutines.experimental.jvm.internal.CoroutineImpl).facade
-
-// INTERNAL DEFINITIONS
-
-private inline fun <T> buildContinuationByInvokeCall(
-    completion: Continuation<T>,
-    crossinline block: () -> Any?
-): Continuation<Unit> {
-    val continuation =
-        object : Continuation<Unit> {
-            override val context: CoroutineContext
-                get() = completion.context
-
-            override fun resume(value: Unit) {
-                processBareContinuationResume(completion, block)
-            }
-
-            override fun resumeWithException(exception: Throwable) {
-                completion.resumeWithException(exception)
-            }
-        }
-
-    return kotlin.coroutines.experimental.jvm.internal.interceptContinuationIfNeeded(completion.context, continuation)
-}
-
-/**
- * This value is used as a return value of [suspendCoroutineOrReturn] `block` argument to state that
- * the execution was suspended and will not return any result immediately.
- */
-@SinceKotlin("1.1")
-public actual val COROUTINE_SUSPENDED: Any get() = CoroutineSingletons.COROUTINE_SUSPENDED
-
-// Using enum here ensures two important properties:
-//  1. It makes SafeContinuation serializable with all kinds of serialization frameworks (since all of them natively support enums)
-//  2. It improves debugging experience, since you clearly see toString() value of those objects and what package they come from
-private enum class CoroutineSingletons {
-    COROUTINE_SUSPENDED
-}

libraries/stdlib/jvm/src/kotlin/coroutines/experimental/jvm/internal/CoroutineImpl.kt

@@ -1,61 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-package kotlin.coroutines.experimental.jvm.internal
-
-import java.lang.IllegalStateException
-import kotlin.coroutines.experimental.Continuation
-import kotlin.coroutines.experimental.CoroutineContext
-import kotlin.coroutines.experimental.processBareContinuationResume
-import kotlin.jvm.internal.Lambda
-
-/**
- * @suppress
- */
-abstract class CoroutineImpl(
-    arity: Int,
-    @JvmField
-    protected var completion: Continuation<Any?>?
-) : Lambda<Any?>(arity), Continuation<Any?> {
-
-    // label == -1 when coroutine cannot be started (it is just a factory object) or has already finished execution
-    // label == 0 in initial part of the coroutine
-    @JvmField
-    protected var label: Int = if (completion != null) 0 else -1
-
-    private val _context: CoroutineContext? = completion?.context
-
-    override val context: CoroutineContext
-        get() = _context!!
-
-    private var _facade: Continuation<Any?>? = null
-
-    val facade: Continuation<Any?> get() {
-        if (_facade == null) _facade = interceptContinuationIfNeeded(_context!!, this)
-        return _facade!!
-    }
-
-    override fun resume(value: Any?) {
-        processBareContinuationResume(completion!!) {
-            doResume(value, null)
-        }
-    }
-
-    override fun resumeWithException(exception: Throwable) {
-        processBareContinuationResume(completion!!) {
-            doResume(null, exception)
-        }
-    }
-
-    protected abstract fun doResume(data: Any?, exception: Throwable?): Any?
-
-    open fun create(completion: Continuation<*>): Continuation<Unit> {
-        throw IllegalStateException("create(Continuation) has not been overridden")
-    }
-
-    open fun create(value: Any?, completion: Continuation<*>): Continuation<Unit> {
-        throw IllegalStateException("create(Any?;Continuation) has not been overridden")
-    }
-}

libraries/stdlib/jvm/src/kotlin/coroutines/experimental/jvm/internal/CoroutineIntrinsics.kt

@@ -1,23 +0,0 @@
-/*
- * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the license/LICENSE.txt file.
- */
-
-@file:JvmName("CoroutineIntrinsics")
-
-package kotlin.coroutines.experimental.jvm.internal
-
-import kotlin.coroutines.experimental.Continuation
-import kotlin.coroutines.experimental.ContinuationInterceptor
-import kotlin.coroutines.experimental.CoroutineContext
-
-/**
- * @suppress
- */
-fun <T> normalizeContinuation(continuation: Continuation<T>): Continuation<T> =
-    (continuation as? CoroutineImpl)?.facade ?: continuation
-
-internal fun <T> interceptContinuationIfNeeded(
-    context: CoroutineContext,
-    continuation: Continuation<T>
-) = context[ContinuationInterceptor]?.interceptContinuation(continuation) ?: continuation