Scoped builders and exception stacktraces synergy

  * Recover stacktraces via both fast and slow paths in scoped builders
  * Merge stracktraces of nested scoped builders, eliminate common prefix so it looks like a flat profile
  * Optimize stacktrace-related machinery
  * Copy meaningful part of original exception into recovered one, rename "Current coroutine stacktrace" to "Coroutien boundary"
  * Rename Exception.kt to StackTraceRecovery.kt to avoid name clash with another Exception.kt

Author: qwwdfsad

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

@@ -280,4 +280,6 @@ internal fun <T> DispatchedTask<T>.resume(delegate: Continuation<T>, useMode: In
 
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun Continuation<*>.resumeWithStackTrace(exception: Throwable) = resumeWith(Result.failure(recoverStackTrace(exception, this)))
+internal inline fun Continuation<*>.resumeWithStackTrace(exception: Throwable) {
+    resumeWith(Result.failure(recoverStackTrace(exception, this)))
+}

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

@@ -243,7 +243,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
         var suppressed = false
         for (exception in exceptions) {
             val unwrapped = unwrap(exception)
-            if (unwrapped !== rootCause && unwrapped !is CancellationException && seenExceptions.add(exception)) {
+            if (unwrapped !== rootCause && unwrapped !is CancellationException && seenExceptions.add(unwrapped)) {
                 rootCause.addSuppressedThrowable(unwrapped)
                 suppressed = true
             }

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

@@ -4,6 +4,7 @@
 
 package kotlinx.coroutines
 
+import kotlinx.coroutines.internal.*
 import kotlinx.coroutines.intrinsics.*
 import kotlinx.coroutines.selects.*
 import kotlin.coroutines.*
@@ -80,9 +81,10 @@ private fun <U, T: U> setupTimeout(
 private open class TimeoutCoroutine<U, in T: U>(
     @JvmField val time: Long,
     @JvmField val uCont: Continuation<U> // unintercepted continuation
-) : AbstractCoroutine<T>(uCont.context, active = true), Runnable, Continuation<T> {
+) : AbstractCoroutine<T>(uCont.context, active = true), Runnable, Continuation<T>, CoroutineStackFrame {
     override val defaultResumeMode: Int get() = MODE_DIRECT
-
+    override val callerFrame: CoroutineStackFrame? get() = (uCont as? CoroutineStackFrame)?.callerFrame
+    override fun getStackTraceElement(): StackTraceElement? = (uCont as? CoroutineStackFrame)?.getStackTraceElement()
     @Suppress("LeakingThis", "Deprecation")
     override fun run() {
         cancel(TimeoutCancellationException(time, this))

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

@@ -21,13 +21,20 @@ internal open class ScopeCoroutine<in T>(
 
     @Suppress("UNCHECKED_CAST")
     internal override fun onCompletionInternal(state: Any?, mode: Int, suppressed: Boolean) {
-        if (state is CompletedExceptionally)
-            uCont.resumeUninterceptedWithExceptionMode(state.cause, mode)
-        else
+        if (state is CompletedExceptionally) {
+            val exception = if (mode == MODE_IGNORE) state.cause else recoverStackTrace(state.cause, uCont)
+            uCont.resumeUninterceptedWithExceptionMode(exception, mode)
+        } else {
             uCont.resumeUninterceptedMode(state as T, mode)
+        }
     }
 }
 
+internal fun AbstractCoroutine<*>.tryRecover(exception: Throwable): Throwable {
+    val cont = (this as? ScopeCoroutine<*>)?.uCont ?: return exception
+    return recoverStackTrace(exception, cont)
+}
+
 internal class ContextScope(context: CoroutineContext) : CoroutineScope {
     override val coroutineContext: CoroutineContext = context
 }

common/kotlinx-coroutines-core-common/src/internal/Exceptions.common.kt renamed to common/kotlinx-coroutines-core-common/src/internal/StackTraceRecovery.common.kt

@@ -5,6 +5,7 @@
 package kotlinx.coroutines.intrinsics
 
 import kotlinx.coroutines.*
+import kotlinx.coroutines.internal.*
 import kotlin.coroutines.*
 import kotlin.coroutines.intrinsics.*
 
@@ -126,8 +127,8 @@ private inline fun <T> AbstractCoroutine<T>.undispatchedResult(
             val state = state
             if (state is CompletedExceptionally) {
                 when {
-                    shouldThrow(state.cause) -> throw state.cause
-                    result is CompletedExceptionally -> throw result.cause
+                    shouldThrow(state.cause) -> throw tryRecover(state.cause)
+                    result is CompletedExceptionally -> throw tryRecover(result.cause)
                     else -> result
                 }
             } else {

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

@@ -29,7 +29,7 @@ public class TestException1(message: String? = null) : Throwable(message), NonRe
 public class TestException2(message: String? = null) : Throwable(message), NonRecoverableThrowable
 public class TestException3(message: String? = null) : Throwable(message), NonRecoverableThrowable
 public class TestRuntimeException(message: String? = null) : RuntimeException(message), NonRecoverableThrowable
-public class RecoverableTestException(message: String? = null) : Throwable(message)
+public class RecoverableTestException(message: String? = null) : RuntimeException(message)
 
 public fun wrapperDispatcher(context: CoroutineContext): CoroutineContext {
     val dispatcher = context[ContinuationInterceptor] as CoroutineDispatcher

common/kotlinx-coroutines-core-common/test/TestBase.common.kt

@@ -9,7 +9,8 @@ import java.util.concurrent.locks.*
 import kotlin.concurrent.*
 
 private val cacheLock = ReentrantReadWriteLock()
-private val exceptionConstructors: WeakHashMap<Class<*>, (Throwable) -> Throwable?> = WeakHashMap()
+// Replace it with ClassValue when Java 6 support is over
+private val exceptionConstructors: WeakHashMap<Class<out Throwable>, (Throwable) -> Throwable?> = WeakHashMap()
 
 @Suppress("UNCHECKED_CAST")
 internal fun <E : Throwable> tryCopyException(exception: E): E? {
@@ -24,7 +25,6 @@ internal fun <E : Throwable> tryCopyException(exception: E): E? {
      * Exceptions are shared among coroutines, so we should copy exception before recovering current stacktrace.
      */
     var ctor: ((Throwable) -> Throwable?)? = null
-
     val constructors = exception.javaClass.constructors.sortedByDescending { it.parameterTypes.size }
     for (constructor in constructors) {
         val parameters = constructor.parameterTypes