Remove some constant parameters and simplify the implementation (#4183)

Author: dkhalanskyjb

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

@@ -5,17 +5,10 @@ import kotlinx.coroutines.internal.*
 import kotlin.coroutines.*
 import kotlin.jvm.*
 
-internal fun <T> Result<T>.toState(
-    onCancellation: ((cause: Throwable) -> Unit)? = null
-): Any? = fold(
-    onSuccess = { if (onCancellation != null) CompletedWithCancellation(it, onCancellation) else it },
-    onFailure = { CompletedExceptionally(it) }
-)
+internal fun <T> Result<T>.toState(): Any? = getOrElse { CompletedExceptionally(it) }
 
-internal fun <T> Result<T>.toState(caller: CancellableContinuation<*>): Any? = fold(
-    onSuccess = { it },
-    onFailure = { CompletedExceptionally(recoverStackTrace(it, caller)) }
-)
+internal fun <T> Result<T>.toState(caller: CancellableContinuation<*>): Any? =
+    getOrElse { CompletedExceptionally(recoverStackTrace(it, caller)) }
 
 @Suppress("RESULT_CLASS_IN_RETURN_TYPE", "UNCHECKED_CAST")
 internal fun <T> recoverResult(state: Any?, uCont: Continuation<T>): Result<T> =
@@ -24,11 +17,6 @@ internal fun <T> recoverResult(state: Any?, uCont: Continuation<T>): Result<T> =
     else
         Result.success(state as T)
 
-internal data class CompletedWithCancellation(
-    @JvmField val result: Any?,
-    @JvmField val onCancellation: (cause: Throwable) -> Unit
-)
-
 /**
  * Class for an internal state of a job that was cancelled (completed exceptionally).
  *

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

@@ -186,15 +186,14 @@ internal class DispatchedContinuation<in T>(
         get() = this
 
     override fun resumeWith(result: Result<T>) {
-        val context = continuation.context
         val state = result.toState()
         if (dispatcher.isDispatchNeeded(context)) {
             _state = state
             resumeMode = MODE_ATOMIC
             dispatcher.dispatch(context, this)
         } else {
             executeUnconfined(state, MODE_ATOMIC) {
-                withCoroutineContext(this.context, countOrElement) {
+                withCoroutineContext(context, countOrElement) {
                     continuation.resumeWith(result)
                 }
             }
@@ -204,11 +203,8 @@ internal class DispatchedContinuation<in T>(
     // We inline it to save an entry on the stack in cases where it shows (unconfined dispatcher)
     // It is used only in Continuation<T>.resumeCancellableWith
     @Suppress("NOTHING_TO_INLINE")
-    internal inline fun resumeCancellableWith(
-        result: Result<T>,
-        noinline onCancellation: ((cause: Throwable) -> Unit)?
-    ) {
-        val state = result.toState(onCancellation)
+    internal inline fun resumeCancellableWith(result: Result<T>) {
+        val state = result.toState()
         if (dispatcher.isDispatchNeeded(context)) {
             _state = state
             resumeMode = MODE_CANCELLABLE
@@ -222,15 +218,6 @@ internal class DispatchedContinuation<in T>(
         }
     }
 
-    // takeState had already cleared the state so we cancel takenState here
-    override fun cancelCompletedResult(takenState: Any?, cause: Throwable) {
-        // It is Ok to call onCancellation here without try/catch around it, since this function only faces
-        // a "bound" cancellation handler that performs the safe call to the user-specified code.
-        if (takenState is CompletedWithCancellation) {
-            takenState.onCancellation(cause)
-        }
-    }
-
     // inline here is to save us an entry on the stack for the sake of better stacktraces
     @Suppress("NOTHING_TO_INLINE")
     internal inline fun resumeCancelled(state: Any?): Boolean {
@@ -271,9 +258,8 @@ internal class DispatchedContinuation<in T>(
 @InternalCoroutinesApi
 public fun <T> Continuation<T>.resumeCancellableWith(
     result: Result<T>,
-    onCancellation: ((cause: Throwable) -> Unit)? = null
 ): Unit = when (this) {
-    is DispatchedContinuation -> resumeCancellableWith(result, onCancellation)
+    is DispatchedContinuation -> resumeCancellableWith(result)
     else -> resumeWith(result)
 }
 

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

@@ -22,11 +22,9 @@ public fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuat
  */
 internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(
     receiver: R, completion: Continuation<T>,
-    onCancellation: ((cause: Throwable) -> Unit)? = null
-) =
-    runSafely(completion) {
-        createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellableWith(Result.success(Unit), onCancellation)
-    }
+) = runSafely(completion) {
+    createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellableWith(Result.success(Unit))
+}
 
 /**
  * Similar to [startCoroutineCancellable], but for already created coroutine.

kotlinx-coroutines-debug/test/CoroutinesDumpTest.kt

@@ -32,7 +32,6 @@ class CoroutinesDumpTest : DebugTestBase() {
                     "\tat _COROUTINE._CREATION._(CoroutineDebugging.kt)\n" +
                     "\tat kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(IntrinsicsJvm.kt)\n" +
                     "\tat kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable(Cancellable.kt)\n" +
-                    "\tat kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable\$default(Cancellable.kt)\n" +
                     "\tat kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt)\n",
             ignoredCoroutine = "BlockingCoroutine"
         ) {
@@ -60,7 +59,6 @@ class CoroutinesDumpTest : DebugTestBase() {
                     "\tat _COROUTINE._CREATION._(CoroutineDebugging.kt)\n" +
                     "\tat kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(IntrinsicsJvm.kt)\n" +
                     "\tat kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable(Cancellable.kt)\n" +
-                    "\tat kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable\$default(Cancellable.kt)\n" +
                     "\tat kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt)\n" +
                     "\tat kotlinx.coroutines.AbstractCoroutine.start(AbstractCoroutine.kt)\n" +
                     "\tat kotlinx.coroutines.BuildersKt__Builders_commonKt.async(Builders.common.kt)\n" +
@@ -91,7 +89,6 @@ class CoroutinesDumpTest : DebugTestBase() {
                     "\tat _COROUTINE._CREATION._(CoroutineDebugging.kt)\n" +
                     "\tat kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(IntrinsicsJvm.kt)\n" +
                     "\tat kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable(Cancellable.kt)\n" +
-                    "\tat kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable\$default(Cancellable.kt)\n" +
                     "\tat kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt)\n" +
                     "\tat kotlinx.coroutines.AbstractCoroutine.start(AbstractCoroutine.kt)\n" +
                     "\tat kotlinx.coroutines.BuildersKt__Builders_commonKt.async(Builders.common.kt)\n" +
@@ -145,7 +142,6 @@ class CoroutinesDumpTest : DebugTestBase() {
         val expected =
             "kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsJvmKt.createCoroutineUnintercepted(IntrinsicsJvm.kt)\n" +
             "kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable(Cancellable.kt)\n" +
-            "kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable\$default(Cancellable.kt)\n" +
             "kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt)\n" +
             "kotlinx.coroutines.AbstractCoroutine.start(AbstractCoroutine.kt)\n" +
             "kotlinx.coroutines.BuildersKt__Builders_commonKt.async(Builders.common.kt)\n" +