Debug optimizations:

  * Extract call to suspendCoroutineUninterceptedOrReturn behind recoverability check
  * Cache exceptions constructors into WeakHashMap in order to avoid expensive ctor lookup

Author: qwwdfsad

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

@@ -1080,9 +1080,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
             if (state !is Incomplete) {
                 // already complete -- just return result
                 if (state is CompletedExceptionally) { // Slow path to recover stacktrace
-                    suspendCoroutineUninterceptedOrReturn<Unit> {
-                        throw recoverStackTrace(state.cause, it)
-                    }
+                    recoverAndThrow(state.cause)
                 }
                 return state
 

core/kotlinx-coroutines-core/src/internal/Exceptions.kt

@@ -65,7 +65,7 @@ internal actual suspend inline fun recoverAndThrow(exception: Throwable): Nothin
     if (recoveryDisabled(exception)) throw exception
     suspendCoroutineUninterceptedOrReturn<Nothing> {
         if (it !is CoroutineStackFrame) throw exception
-        throw  recoverFromStackFrame(exception, it)
+        throw recoverFromStackFrame(exception, it)
     }
 }
 
@@ -86,34 +86,7 @@ internal actual fun <E : Throwable> unwrap(exception: E): E {
 private fun <E : Throwable> recoveryDisabled(exception: E) =
     !RECOVER_STACKTRACE || !DEBUG || exception is CancellationException || exception is NonRecoverableThrowable
 
-@Suppress("UNCHECKED_CAST")
-private fun <E : Throwable> tryCopyException(exception: E): E? {
-    /*
-     * Try to reflectively find constructor(), constructor(message, cause) or constructor(cause).
-     * Exceptions are shared among coroutines, so we should copy exception before recovering current stacktrace.
-     */
-    var newException: E? = null
-    try {
-        val constructors = exception.javaClass.constructors.sortedByDescending { it.parameterTypes.size }
-        for (constructor in constructors) {
-            val parameters = constructor.parameterTypes
-            if (parameters.size == 2 && parameters[0] == String::class.java && parameters[1] == Throwable::class.java) {
-                newException = constructor.newInstance(exception.message, exception) as E
-            } else if (parameters.size == 1 && parameters[0] == Throwable::class.java) {
-                newException = constructor.newInstance(exception) as E
-            } else if (parameters.isEmpty()) {
-                newException = (constructor.newInstance() as E).also { it.initCause(exception) }
-            }
-
-            if (newException != null) {
-                break
-            }
-        }
-    } catch (e: Exception) {
-        // Do nothing
-    }
-    return newException
-}
+
 
 private fun createStackTrace(continuation: CoroutineStackFrame): ArrayList<StackTraceElement> {
     val stack = ArrayList<StackTraceElement>()

core/kotlinx-coroutines-core/src/internal/ExceptionsConstuctor.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.internal
+
+import java.util.*
+import java.util.concurrent.locks.*
+import kotlin.concurrent.*
+
+private val cacheLock = ReentrantReadWriteLock()
+private val exceptionConstructors: WeakHashMap<Class<*>, (Throwable) -> Throwable?> = WeakHashMap()
+
+@Suppress("UNCHECKED_CAST")
+internal fun <E : Throwable> tryCopyException(exception: E): E? {
+    val cachedCtor = cacheLock.read {
+        exceptionConstructors[exception.javaClass]
+    }
+
+    if (cachedCtor != null) return cachedCtor(exception) as E?
+
+    /*
+     * Try to reflectively find constructor(), constructor(message, cause) or constructor(cause).
+     * 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
+        if (parameters.size == 2 && parameters[0] == String::class.java && parameters[1] == Throwable::class.java) {
+            ctor = { e -> runCatching { constructor.newInstance(e.message, e) as E }.getOrNull() }
+            break
+        } else if (parameters.size == 1 && parameters[0] == Throwable::class.java) {
+            ctor = { e -> runCatching { constructor.newInstance(e) as E }.getOrNull() }
+            break
+        } else if (parameters.isEmpty()) {
+            ctor = { e -> runCatching { constructor.newInstance() as E }.getOrNull()?.also { it.initCause(e) } }
+            break
+        }
+    }
+
+    cacheLock.write { exceptionConstructors[exception.javaClass] = ctor }
+    return ctor?.invoke(exception) as E?
+}