Make SupervisorCoroutine implement ScopeCoroutine

* Implement ScopeCoroutine in SupervisorCoroutine
* Do not indent scoped coroutines in debug strings

Fixes #915
Fixes #916

Author: qwwdfsad

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

@@ -37,7 +37,6 @@ public abstract class AbstractCoroutine<in T>(
     /**
      * Context of the parent coroutine.
      */
-
     @JvmField
     protected val parentContext: CoroutineContext,
     active: Boolean = true
@@ -53,7 +52,7 @@ public abstract class AbstractCoroutine<in T>(
      */
     public override val coroutineContext: CoroutineContext get() = context
 
-    override val isActive: Boolean get() = super<JobSupport>.isActive
+    override val isActive: Boolean get() = super.isActive
 
     /**
      * Initializes parent job from the `parentContext` of this coroutine that was passed to it during construction.

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

@@ -6,6 +6,7 @@
 
 package kotlinx.coroutines
 
+import kotlinx.coroutines.internal.*
 import kotlinx.coroutines.intrinsics.*
 import kotlin.coroutines.*
 import kotlin.coroutines.intrinsics.*
@@ -56,18 +57,9 @@ private class SupervisorJobImpl(parent: Job?) : JobImpl(parent) {
     override fun childCancelled(cause: Throwable): Boolean = false
 }
 
-private class SupervisorCoroutine<R>(
-    parentContext: CoroutineContext,
-    @JvmField val uCont: Continuation<R>
-) : AbstractCoroutine<R>(parentContext, true) {
-    override val defaultResumeMode: Int get() = MODE_DIRECT
+private class SupervisorCoroutine<in T>(
+    context: CoroutineContext,
+    uCont: Continuation<T>
+) : ScopeCoroutine<T>(context, uCont) {
     override fun childCancelled(cause: Throwable): Boolean = false
-
-    @Suppress("UNCHECKED_CAST")
-    internal override fun onCompletionInternal(state: Any?, mode: Int, suppressed: Boolean) {
-        if (state is CompletedExceptionally)
-            uCont.resumeUninterceptedWithExceptionMode(state.cause, mode)
-        else
-            uCont.resumeUninterceptedMode(state as R, mode)
-    }
 }

kotlinx-coroutines-core/jvm/test/exceptions/StackTraceRecoveryTest.kt

@@ -180,6 +180,7 @@ class StackTraceRecoveryTest : TestBase() {
                     "\t(Coroutine boundary)\n" +
                     "\tat kotlinx.coroutines.DeferredCoroutine.await\$suspendImpl(Builders.common.kt:99)\n" +
                     "\tat kotlinx.coroutines.exceptions.StackTraceRecoveryTest.innerMethod(StackTraceRecoveryTest.kt:158)\n" +
+                    "\tat kotlinx.coroutines.exceptions.StackTraceRecoveryTest\$outerScopedMethod\$2\$1.invokeSuspend(StackTraceRecoveryTest.kt:193)\n" +
                     "\tat kotlinx.coroutines.exceptions.StackTraceRecoveryTest\$outerScopedMethod\$2.invokeSuspend(StackTraceRecoveryTest.kt:151)\n" +
                     "\tat kotlinx.coroutines.exceptions.StackTraceRecoveryTest\$testCoroutineScope\$1.invokeSuspend(StackTraceRecoveryTest.kt:141)\n",
             "Caused by: kotlinx.coroutines.RecoverableTestException\n" +
@@ -217,7 +218,10 @@ class StackTraceRecoveryTest : TestBase() {
     }
 
     private suspend fun outerScopedMethod(deferred: Deferred<Nothing>, vararg traces: String) = coroutineScope {
-        innerMethod(deferred, *traces)
+        supervisorScope {
+            innerMethod(deferred, *traces)
+            assertTrue(true)
+        }
         assertTrue(true)
     }
 

kotlinx-coroutines-debug/src/internal/DebugProbesImpl.kt

@@ -76,24 +76,32 @@ internal object DebugProbesImpl {
 
     private fun Job.build(map: Map<Job, CoroutineState>, builder: StringBuilder, indent: String) {
         val state = map[this]
-        builder.append(indent)
-        @Suppress("DEPRECATION_ERROR")
-        val str = if (this !is JobSupport) toString() else toDebugString()
-        if (state == null) {
+        val newIndent: String
+        if (state == null) { // Append coroutine without stacktrace
+            // Do not print scoped coroutines and do not increase indentation level
             @Suppress("INVISIBLE_REFERENCE")
-            if (this !is kotlinx.coroutines.internal.ScopeCoroutine<*>) { // Do not print scoped coroutines
-                builder.append("$str\n")
+            if (this !is kotlinx.coroutines.internal.ScopeCoroutine<*>) {
+                builder.append("$indent$debugString\n")
+                newIndent = indent + "\t"
+            } else {
+                newIndent = indent
             }
         } else {
+            // Append coroutine with its last stacktrace element
             val element = state.lastObservedStackTrace().firstOrNull()
             val contState = state.state
-            builder.append("$str, continuation is $contState at line $element\n")
+            builder.append("$indent$debugString, continuation is $contState at line $element\n")
+            newIndent = indent + "\t"
         }
+        // Append children with new indent
         for (child in children) {
-            child.build(map, builder, indent + "\t")
+            child.build(map, builder, newIndent)
         }
     }
 
+    @Suppress("DEPRECATION_ERROR") // JobSupport
+    private val Job.debugString: String get() = if (this is JobSupport) toDebugString() else toString()
+
     @Synchronized
     public fun dumpCoroutinesState(): List<CoroutineState> {
         check(isInstalled) { "Debug probes are not installed" }

kotlinx-coroutines-debug/test/ToStringTest.kt

@@ -29,6 +29,50 @@ class ToStringTest : TestBase() {
         }
     }
 
+
+    private suspend fun CoroutineScope.launchNestedScopes(): Job {
+        return launch {
+            expect(1)
+            coroutineScope {
+                expect(2)
+                launchDelayed()
+
+                supervisorScope {
+                    expect(3)
+                    launchDelayed()
+                }
+            }
+        }
+    }
+
+    private fun CoroutineScope.launchDelayed(): Job {
+        return launch {
+            delay(Long.MAX_VALUE)
+        }
+    }
+
+    @Test
+    fun testPrintHierarchyWithScopes() = runBlocking {
+        val tab = '\t'
+        val expectedString = """
+          "coroutine":StandaloneCoroutine{Active}, continuation is SUSPENDED at line ToStringTest${'$'}launchNestedScopes$2$1.invokeSuspend(ToStringTest.kt)
+          $tab"coroutine":StandaloneCoroutine{Active}, continuation is SUSPENDED at line ToStringTest${'$'}launchDelayed$1.invokeSuspend(ToStringTest.kt)
+          $tab"coroutine":StandaloneCoroutine{Active}, continuation is SUSPENDED at line ToStringTest${'$'}launchDelayed$1.invokeSuspend(ToStringTest.kt)
+            """.trimIndent()
+
+        val job = launchNestedScopes()
+        try {
+            repeat(5) { yield() }
+            val expected = expectedString.trimStackTrace().trimPackage()
+            expect(4)
+            assertEquals(expected, DebugProbes.jobToString(job).trimEnd().trimStackTrace().trimPackage())
+            assertEquals(expected, DebugProbes.scopeToString(CoroutineScope(job)).trimEnd().trimStackTrace().trimPackage())
+        } finally {
+            finish(5)
+            job.cancelAndJoin()
+        }
+    }
+
     @Test
     fun testCompletingHierarchy() = runBlocking {
         val tab = '\t'
@@ -62,8 +106,7 @@ class ToStringTest : TestBase() {
         assertEquals(expected, DebugProbes.jobToString(root).trimEnd().trimStackTrace().trimPackage())
         assertEquals(expected, DebugProbes.scopeToString(CoroutineScope(root)).trimEnd().trimStackTrace().trimPackage())
 
-        root.cancel()
-        root.join()
+        root.cancelAndJoin()
         finish(7)
     }