Make TimeoutCancellationException copyable

    * Make CopyableThrowable common, so multiplatform exceptions could be recovered on JVM

Author: qwwdfsad

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

@@ -8,3 +8,33 @@ internal expect val DEBUG: Boolean
 internal expect val Any.hexAddress: String
 internal expect val Any.classSimpleName: String
 internal expect fun assert(value: () -> Boolean)
+
+/**
+ * Throwable which can be cloned during stacktrace recovery in a class-specific way.
+ * For additional information about stacktrace recovery see [STACKTRACE_RECOVERY_PROPERTY_NAME]
+ *
+ * Example of usage:
+ * ```
+ * class BadResponseCodeException(val responseCode: Int) : Exception(), CopyableThrowable<BadResponseCodeException> {
+ *
+ *  override fun createCopy(): BadResponseCodeException {
+ *    val result = BadResponseCodeException(responseCode)
+ *    result.initCause(this)
+ *    return result
+ *  }
+ * ```
+ *
+ * Copy mechanism is used only on JVM, but it might be convenient to implement it in common exceptions,
+ * so on JVM their stacktraces will be properly recovered.
+ */
+@ExperimentalCoroutinesApi
+public interface CopyableThrowable<T> where T : Throwable, T : CopyableThrowable<T> {
+
+    /**
+     * Creates a copy of the current instance.
+     * For better debuggability, it is recommended to use original exception as [cause][Throwable.cause] of the resulting one.
+     * Stacktrace of copied exception will be overwritten by stacktrace recovery machinery by [Throwable.setStackTrace] call.
+     * An exception can opt-out of copying by returning `null` from this function.
+     */
+    public fun createCopy(): T?
+}

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

@@ -78,7 +78,7 @@ private fun <U, T: U> setupTimeout(
     return coroutine.startUndispatchedOrReturnIgnoreTimeout(coroutine, block)
 }
 
-private open class TimeoutCoroutine<U, in T: U>(
+private class TimeoutCoroutine<U, in T: U>(
     @JvmField val time: Long,
     uCont: Continuation<U> // unintercepted continuation
 ) : ScopeCoroutine<T>(uCont.context, uCont), Runnable {
@@ -96,13 +96,17 @@ private open class TimeoutCoroutine<U, in T: U>(
 public class TimeoutCancellationException internal constructor(
     message: String,
     @JvmField internal val coroutine: Job?
-) : CancellationException(message) {
+) : CancellationException(message), CopyableThrowable<TimeoutCancellationException> {
     /**
      * Creates a timeout exception with the given message.
      * This constructor is needed for exception stack-traces recovery.
      */
     @Suppress("UNUSED")
     internal constructor(message: String) : this(message, null)
+
+    // message is never null in fact
+    override fun createCopy(): TimeoutCancellationException? =
+        TimeoutCancellationException(message ?: "", coroutine).also { it.initCause(this) }
 }
 
 @Suppress("FunctionName")

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

@@ -17,6 +17,11 @@ import kotlin.coroutines.*
  */
 internal expect fun <E: Throwable> recoverStackTrace(exception: E, continuation: Continuation<*>): E
 
+/**
+ * initCause on JVM, nop on other platforms
+ */
+internal expect fun Throwable.initCause(cause: Throwable)
+
 /**
  * Tries to recover stacktrace for given [exception]. Used in non-suspendable points of awaiting.
  * Stacktrace recovery tries to instantiate exception of given type with original exception as a cause.

kotlinx-coroutines-core/js/src/internal/StackTraceRecovery.kt

@@ -20,3 +20,6 @@ internal actual interface CoroutineStackFrame {
 
 @Suppress("ACTUAL_WITHOUT_EXPECT")
 internal actual typealias StackTraceElement = Any
+
+internal actual fun Throwable.initCause(cause: Throwable) {
+}

kotlinx-coroutines-core/jvm/src/Debug.kt

@@ -48,33 +48,6 @@ public const val DEBUG_PROPERTY_NAME = "kotlinx.coroutines.debug"
  */
 internal const val STACKTRACE_RECOVERY_PROPERTY_NAME = "kotlinx.coroutines.stacktrace.recovery"
 
-/**
- * Throwable which can be cloned during stacktrace recovery in a class-specific way.
- * For additional information about stacktrace recovery see [STACKTRACE_RECOVERY_PROPERTY_NAME]
- *
- * Example of usage:
- * ```
- * class BadResponseCodeException(val responseCode: Int) : Exception(), CopyableThrowable<BadResponseCodeException> {
- *
- *  override fun createCopy(): BadResponseCodeException {
- *    val result = BadResponseCodeException(responseCode)
- *    result.initCause(this)
- *    return result
- *  }
- * ```
- */
-@ExperimentalCoroutinesApi
-public interface CopyableThrowable<T> where T : Throwable, T : CopyableThrowable<T> {
-
-    /**
-     * Creates a copy of the current instance.
-     * For better debuggability, it is recommended to use original exception as [cause][Throwable.cause] of the resulting one.
-     * Stacktrace of copied exception will be overwritten by stacktrace recovery machinery by [Throwable.setStackTrace] call.
-     * An exception can opt-out of copying by returning `null` from this function.
-     */
-    public fun createCopy(): T?
-}
-
 /**
  * Automatic debug configuration value for [DEBUG_PROPERTY_NAME].
  */

kotlinx-coroutines-core/jvm/src/internal/StackTraceRecovery.kt

@@ -204,3 +204,8 @@ internal actual typealias CoroutineStackFrame = kotlin.coroutines.jvm.internal.C
 
 @Suppress("ACTUAL_WITHOUT_EXPECT")
 internal actual typealias StackTraceElement = java.lang.StackTraceElement
+
+internal actual fun Throwable.initCause(cause: Throwable) {
+    // Resolved to member, verified by test
+    initCause(cause)
+}

kotlinx-coroutines-core/native/src/internal/StackTraceRecovery.kt

@@ -19,3 +19,6 @@ internal actual interface CoroutineStackFrame {
 
 @Suppress("ACTUAL_WITHOUT_EXPECT")
 internal actual typealias StackTraceElement = Any
+
+internal actual fun Throwable.initCause(cause: Throwable) {
+}