Merge branch 'develop' into stacktrace-recovery

# Conflicts:
#	common/kotlinx-coroutines-core-common/src/JobSupport.kt
#	core/kotlinx-coroutines-core/test/exceptions/SuppressionTests.kt

Author: qwwdfsad

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-core.txt

@@ -630,7 +630,6 @@ public final class kotlinx/coroutines/channels/ClosedSendChannelException : java
 }
 
 public final class kotlinx/coroutines/channels/ConflatedBroadcastChannel : kotlinx/coroutines/channels/BroadcastChannel {
-	public static final field Companion Lkotlinx/coroutines/channels/ConflatedBroadcastChannel$Companion;
 	public fun <init> ()V
 	public fun <init> (Ljava/lang/Object;)V
 	public fun cancel (Ljava/lang/Throwable;)Z

build.gradle

@@ -193,10 +193,11 @@ configure(subprojects.findAll { !unpublished.contains(it.name) }) {
     tasks.withType(org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile).all {
         kotlinOptions.freeCompilerArgs += ["-Xuse-experimental=kotlin.Experimental",
                                            "-Xuse-experimental=kotlin.experimental.ExperimentalTypeInference",
+                                           "-Xuse-experimental=kotlin.ExperimentalMultiplatform",
                                            "-Xuse-experimental=kotlinx.coroutines.ExperimentalCoroutinesApi",
                                            "-Xuse-experimental=kotlinx.coroutines.ObsoleteCoroutinesApi",
-                                           "-Xuse-experimental=kotlinx.coroutines.InternalCoroutinesApi"]
-
+                                           "-Xuse-experimental=kotlinx.coroutines.InternalCoroutinesApi",
+                                           "-progressive"]
     }
 }
 

common/kotlinx-coroutines-core-common/src/AbstractContinuation.kt

@@ -277,6 +277,7 @@ internal abstract class AbstractContinuation<in T>(
 internal interface NotCompleted
 
 private class Active : NotCompleted
+@SharedImmutable
 private val ACTIVE: Active = Active()
 
 internal abstract class CancelHandler : CancelHandlerBase(), NotCompleted

common/kotlinx-coroutines-core-common/src/Builders.common.kt

@@ -228,7 +228,7 @@ private class DispatchedCoroutine<in T>(
     fun getResult(): Any? {
         if (trySuspend()) return COROUTINE_SUSPENDED
         // otherwise, onCompletionInternal was already invoked & invoked tryResume, and the result is in the state
-        val state = this.state
+        val state = this.state.unboxState()
         if (state is CompletedExceptionally) throw state.cause
         @Suppress("UNCHECKED_CAST")
         return state as T

common/kotlinx-coroutines-core-common/src/CoroutineExceptionHandler.kt

@@ -65,7 +65,7 @@ internal fun handlerException(originalException: Throwable, thrownException: Thr
  */
 @Suppress("FunctionName")
 public inline fun CoroutineExceptionHandler(crossinline handler: (CoroutineContext, Throwable) -> Unit): CoroutineExceptionHandler =
-    object: AbstractCoroutineContextElement(CoroutineExceptionHandler), CoroutineExceptionHandler {
+    object : AbstractCoroutineContextElement(CoroutineExceptionHandler), CoroutineExceptionHandler {
         override fun handleException(context: CoroutineContext, exception: Throwable) =
             handler.invoke(context, exception)
     }

common/kotlinx-coroutines-core-common/src/Dispatched.kt

@@ -9,6 +9,7 @@ import kotlin.coroutines.*
 import kotlin.jvm.*
 
 @Suppress("PrivatePropertyName")
+@SharedImmutable
 private val UNDEFINED = Symbol("UNDEFINED")
 
 @NativeThreadLocal

common/kotlinx-coroutines-core-common/src/JobSupport.kt

@@ -154,10 +154,10 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
     }
 
     // ------------ state query ------------
-
     /**
      * Returns current state of this job.
-     * @suppress **This is unstable API and it is subject to change.**
+     * If final state of the job is [Incomplete], then it is boxed into [IncompleteStateBox]
+     * and should be [unboxed][unboxState] before returning to user code.
      */
     internal val state: Any? get() {
         _state.loop { state -> // helper loop on state (complete in-progress atomic operations)
@@ -192,7 +192,12 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
     // Finalizes Finishing -> Completed (terminal state) transition.
     // ## IMPORTANT INVARIANT: Only one thread can be concurrently invoking this method.
     private fun tryFinalizeFinishingState(state: Finishing, proposedUpdate: Any?, mode: Int): Boolean {
-        require(proposedUpdate !is Incomplete) // only incomplete -> completed transition is allowed
+        /*
+         * Note: proposed state can be Incompleted, e.g.
+         * async {
+         *   smth.invokeOnCompletion {} // <- returns handle which implements Incomplete under the hood
+         * }
+         */
         require(this.state === state) // consistency check -- it cannot change
         require(!state.isSealed) // consistency check -- cannot be sealed yet
         require(state.isCompleting) // consistency check -- must be marked as completing
@@ -220,7 +225,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
             handleJobException(finalException)
         }
         // Then CAS to completed state -> it must succeed
-        require(_state.compareAndSet(state, finalState)) { "Unexpected state: ${_state.value}, expected: $state, update: $finalState" }
+        require(_state.compareAndSet(state, finalState.boxIncomplete())) { "Unexpected state: ${_state.value}, expected: $state, update: $finalState" }
         // And process all post-completion actions
         completeStateFinalization(state, finalState, mode, suppressed)
         return true
@@ -255,7 +260,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
     private fun tryFinalizeSimpleState(state: Incomplete, update: Any?, mode: Int): Boolean {
         check(state is Empty || state is JobNode<*>) // only simple state without lists where children can concurrently add
         check(update !is CompletedExceptionally) // only for normal completion
-        if (!_state.compareAndSet(state, update)) return false
+        if (!_state.compareAndSet(state, update.boxIncomplete())) return false
         completeStateFinalization(state, update, mode, false)
         return true
     }
@@ -1067,7 +1072,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
         val state = this.state
         check(state !is Incomplete) { "This job has not completed yet" }
         if (state is CompletedExceptionally) throw state.cause
-        return state
+        return state.unboxState()
     }
 
     /**
@@ -1082,7 +1087,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
                 if (state is CompletedExceptionally) { // Slow path to recover stacktrace
                     recoverAndThrow(state.cause)
                 }
-                return state
+                return state.unboxState()
 
             }
             if (startInternal(state) >= 0) break // break unless needs to retry
@@ -1114,10 +1119,12 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
             if (state !is Incomplete) {
                 // already complete -- select result
                 if (select.trySelect(null)) {
-                    if (state is CompletedExceptionally)
+                    if (state is CompletedExceptionally) {
                         select.resumeSelectCancellableWithException(state.cause)
-                    else
-                        block.startCoroutineUnintercepted(state as T, select.completion)
+                    }
+                    else {
+                        block.startCoroutineUnintercepted(state.unboxState() as T, select.completion)
+                    }
                 }
                 return
             }
@@ -1139,10 +1146,17 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
         if (state is CompletedExceptionally)
             select.resumeSelectCancellableWithException(state.cause)
         else
-            block.startCoroutineCancellable(state as T, select.completion)
+            block.startCoroutineCancellable(state.unboxState() as T, select.completion)
     }
 }
 
+/*
+ * Class to represent object as the final state of the Job
+ */
+private class IncompleteStateBox(@JvmField val state: Incomplete)
+private fun Any?.boxIncomplete(): Any? = if (this is Incomplete) IncompleteStateBox(this) else this
+internal fun Any?.unboxState(): Any? = (this as? IncompleteStateBox)?.state ?: this
+
 // --------------- helper classes & constants for job implementation
 
 private const val COMPLETING_ALREADY_COMPLETING = 0
@@ -1154,9 +1168,11 @@ private const val RETRY = -1
 private const val FALSE = 0
 private const val TRUE = 1
 
+@SharedImmutable
 private val SEALED = Symbol("SEALED")
-
+@SharedImmutable
 private val EMPTY_NEW = Empty(false)
+@SharedImmutable
 private val EMPTY_ACTIVE = Empty(true)
 
 private class Empty(override val isActive: Boolean) : Incomplete {
@@ -1241,7 +1257,7 @@ private class ResumeAwaitOnCompletion<T>(
         } else {
             // Resuming with value in a cancellable way (AwaitContinuation is configured for this mode).
             @Suppress("UNCHECKED_CAST")
-            continuation.resume(state as T)
+            continuation.resume(state.unboxState() as T)
         }
     }
     override fun toString() = "ResumeAwaitOnCompletion[$continuation]"

common/kotlinx-coroutines-core-common/src/SchedulerTask.common.kt

@@ -8,6 +8,8 @@ internal expect abstract class SchedulerTask() : Runnable
 
 internal expect interface SchedulerTaskContext
 
+@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
 internal expect val SchedulerTask.taskContext: SchedulerTaskContext
 
+@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
 internal expect inline fun SchedulerTaskContext.afterTask()

common/kotlinx-coroutines-core-common/src/Timeout.kt

@@ -26,7 +26,7 @@ import kotlin.jvm.*
  * @param timeMillis timeout time in milliseconds.
  */
 public suspend fun <T> withTimeout(timeMillis: Long, block: suspend CoroutineScope.() -> T): T {
-    if (timeMillis <= 0L) throw CancellationException("Timed out immediately")
+    if (timeMillis <= 0L) throw TimeoutCancellationException("Timed out immediately")
     return suspendCoroutineUninterceptedOrReturn { uCont ->
         setupTimeout(TimeoutCoroutine(timeMillis, uCont), block)
     }

common/kotlinx-coroutines-core-common/src/channels/AbstractChannel.kt

@@ -1003,32 +1003,43 @@ internal abstract class AbstractChannel<E> : AbstractSendChannel<E>(), Channel<E
     )
 }
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val OFFER_SUCCESS: Any = Symbol("OFFER_SUCCESS")
+@JvmField
+@SharedImmutable
+internal val OFFER_SUCCESS: Any = Symbol("OFFER_SUCCESS")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val OFFER_FAILED: Any = Symbol("OFFER_FAILED")
+@JvmField
+@SharedImmutable
+internal val OFFER_FAILED: Any = Symbol("OFFER_FAILED")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val POLL_FAILED: Any = Symbol("POLL_FAILED")
+@JvmField
+@SharedImmutable
+internal val POLL_FAILED: Any = Symbol("POLL_FAILED")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val ENQUEUE_FAILED: Any = Symbol("ENQUEUE_FAILED")
+@JvmField
+@SharedImmutable
+internal val ENQUEUE_FAILED: Any = Symbol("ENQUEUE_FAILED")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val SELECT_STARTED: Any = Symbol("SELECT_STARTED")
+@JvmField
+@SharedImmutable
+internal val SELECT_STARTED: Any = Symbol("SELECT_STARTED")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val NULL_VALUE: Any = Symbol("NULL_VALUE")
+@JvmField
+@SharedImmutable
+internal val NULL_VALUE: Any = Symbol("NULL_VALUE")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val CLOSE_RESUMED: Any = Symbol("CLOSE_RESUMED")
+@JvmField
+@SharedImmutable
+internal val CLOSE_RESUMED: Any = Symbol("CLOSE_RESUMED")
 
-/** @suppress **This is unstable API and it is subject to change.** */
-@JvmField internal val SEND_RESUMED = Symbol("SEND_RESUMED")
+@JvmField
+@SharedImmutable
+internal val SEND_RESUMED: Any = Symbol("SEND_RESUMED")
+
+@JvmField
+@SharedImmutable
+internal val HANDLER_INVOKED: Any = Symbol("ON_CLOSE_HANDLER_INVOKED")
 
 internal typealias Handler = (Throwable?) -> Unit
-@JvmField internal val HANDLER_INVOKED = Any()
 
 /**
  * Represents sending waiter in the queue.

common/kotlinx-coroutines-core-common/src/channels/Channels.common.kt

@@ -60,8 +60,10 @@ public suspend inline fun <E> BroadcastChannel<E>.consumeEach(action: (E) -> Uni
  *           See [issue #254](https://github.com/Kotlin/kotlinx.coroutines/issues/254).
  */
 @ObsoleteCoroutinesApi
-public fun ReceiveChannel<*>.consumes(): CompletionHandler =
-    { cause: Throwable? -> cancel(cause) }
+public fun ReceiveChannel<*>.consumes(): CompletionHandler = { cause: Throwable? ->
+        @Suppress("DEPRECATION")
+        cancel(cause)
+    }
 
 /**
  * Returns a [CompletionHandler] that invokes [cancel][ReceiveChannel.cancel] on all the
@@ -77,6 +79,7 @@ public fun consumesAll(vararg channels: ReceiveChannel<*>): CompletionHandler =
         var exception: Throwable? = null
         for (channel in channels)
             try {
+                @Suppress("DEPRECATION")
                 channel.cancel(cause)
             } catch (e: Throwable) {
                 if (exception == null) {
@@ -112,6 +115,7 @@ public inline fun <E, R> ReceiveChannel<E>.consume(block: ReceiveChannel<E>.() -
         cause = e
         throw e
     } finally {
+        @Suppress("DEPRECATION")
         cancel(cause)
     }
 }
@@ -302,7 +306,7 @@ public suspend fun <E> ReceiveChannel<E>.firstOrNull(): E? =
  *           See [issue #254](https://github.com/Kotlin/kotlinx.coroutines/issues/254).
  */
 @ObsoleteCoroutinesApi
-public inline suspend fun <E> ReceiveChannel<E>.firstOrNull(predicate: (E) -> Boolean): E? {
+public suspend inline fun <E> ReceiveChannel<E>.firstOrNull(predicate: (E) -> Boolean): E? {
     consumeEach {
         if (predicate(it)) return it
     }

common/kotlinx-coroutines-core-common/src/channels/ConflatedBroadcastChannel.kt

@@ -46,7 +46,9 @@ public class ConflatedBroadcastChannel<E>() : BroadcastChannel<E> {
     private val onCloseHandler = atomic<Any?>(null)
 
     private companion object {
+        @SharedImmutable
         private val CLOSED = Closed(null)
+        @SharedImmutable
         private val UNDEFINED = Symbol("UNDEFINED")
         private val INITIAL_STATE = State<Any?>(UNDEFINED, null)
     }

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

@@ -20,6 +20,7 @@ public abstract class OpDescriptor {
     abstract fun perform(affected: Any?): Any?
 }
 
+@SharedImmutable
 private val NO_DECISION: Any = Symbol("NO_DECISION")
 
 /**

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

@@ -21,4 +21,8 @@ internal expect class ReentrantLock() {
 
 internal expect inline fun <T> ReentrantLock.withLock(action: () -> T): T
 
-internal expect fun <E> identitySet(expectedSize: Int): MutableSet<E>
+internal expect fun <E> identitySet(expectedSize: Int): MutableSet<E>
+
+@ExperimentalMultiplatform
+@OptionalExpectation
+internal expect annotation class SharedImmutable()

common/kotlinx-coroutines-core-common/src/intrinsics/Undispatched.kt

@@ -132,7 +132,7 @@ private inline fun <T> AbstractCoroutine<T>.undispatchedResult(
                     else -> result
                 }
             } else {
-                state
+                state.unboxState()
             }
         }
         else -> COROUTINE_SUSPENDED

common/kotlinx-coroutines-core-common/src/selects/Select.kt

@@ -186,8 +186,11 @@ public suspend inline fun <R> select(crossinline builder: SelectBuilder<R>.() ->
     }
 
 
+@SharedImmutable
 internal val ALREADY_SELECTED: Any = Symbol("ALREADY_SELECTED")
+@SharedImmutable
 private val UNDECIDED: Any = Symbol("UNDECIDED")
+@SharedImmutable
 private val RESUMED: Any = Symbol("RESUMED")
 
 @PublishedApi