SupervisorJob & supervisorScope

Tentative implementation and name, no docs yet

Fixes #576

Author: elizarov

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.coroutines.experimental
+
+import kotlin.coroutines.experimental.*
+
+@Suppress("FunctionName")
+public fun SupervisorJob(parent: Job? = null) : Job = SupervisorJobImpl(parent)
+
+public suspend fun <R> supervisorScope(block: suspend CoroutineScope.() -> R): R {
+    // todo: optimize implementation to a single allocated object
+    // todo: fix copy-and-paste with coroutineScope
+    val owner = SupervisorCoroutine<R>(coroutineContext)
+    owner.start(CoroutineStart.UNDISPATCHED, owner, block)
+    owner.join()
+    if (owner.isCancelled) {
+        throw owner.getCancellationException().let { it.cause ?: it }
+    }
+    val state = owner.state
+    if (state is CompletedExceptionally) {
+        throw state.cause
+    }
+    @Suppress("UNCHECKED_CAST")
+    return state as R
+
+}
+
+private class SupervisorJobImpl(parent: Job?) : JobSupport(true) {
+    init { initParentJobInternal(parent) }
+    override val onFailComplete get() = true
+    override val handlesException: Boolean get() = false
+    override fun childFailed(cause: Throwable): Boolean = false
+}
+
+private class SupervisorCoroutine<R>(
+    parentContext: CoroutineContext
+) : AbstractCoroutine<R>(parentContext, true) {
+    override fun childFailed(cause: Throwable): Boolean = false
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED") // KT-21913
+
+package kotlinx.coroutines.experimental
+
+import kotlin.test.*
+
+class SupervisorTest : TestBase() {
+    @Test
+    fun testSupervisorJob() = runTest(
+        unhandled = listOf(
+            { it -> it is TestException2 },
+            { it -> it is TestException1 }
+        )
+    ) {
+        expect(1)
+        val supervisor = SupervisorJob()
+        val job1 = launch(supervisor + CoroutineName("job1")) {
+            expect(2)
+            yield() // to second child
+            expect(4)
+            throw TestException1()
+        }
+        val job2 = launch(supervisor + CoroutineName("job2")) {
+            expect(3)
+            throw TestException2()
+        }
+        joinAll(job1, job2)
+        finish(5)
+        assertTrue(job1.isFailed)
+        assertTrue(job2.isFailed)
+    }
+
+    @Test
+    fun testSupervisorScope() = runTest(
+        unhandled = listOf(
+            { it -> it is TestException1 },
+            { it -> it is TestException2 }
+        )
+    ) {
+        val result = supervisorScope {
+            launch {
+                throw TestException1()
+            }
+            launch {
+                throw TestException2()
+            }
+            "OK"
+        }
+        assertEquals("OK", result)
+    }
+
+    private class TestException1 : Exception()
+    private class TestException2 : Exception()
+}

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

@@ -146,7 +146,6 @@ public actual open class TestBase actual constructor() {
                     !unhandled[exCount - 1](e) ->
                         printError("Unhandled exception was unexpected: $e", e)
                 }
-                context[Job]?.cancel(e)
             })
         } catch (e: Throwable) {
             ex = e

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

@@ -81,7 +81,6 @@ public actual open class TestBase actual constructor() {
                 !unhandled[exCount - 1](e) ->
                     printError("Unhandled exception was unexpected: $e", e)
             }
-            context[Job]?.cancel(e)
         }).catch { e ->
             ex = e
             if (expected != null) {

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

@@ -76,7 +76,6 @@ public actual open class TestBase actual constructor() {
                     !unhandled[exCount - 1](e) ->
                         printError("Unhandled exception was unexpected: $e", e)
                 }
-                context[Job]?.cancel(e)
             })
         } catch (e: Throwable) {
             ex = e