Fail-fast if coroutine start internal machinery has failed: treat any internal exception as coroutine result and invoke completion with such exception

Fixes #880

Author: qwwdfsad

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

@@ -12,12 +12,29 @@ import kotlin.coroutines.intrinsics.*
  * Use this function to start coroutine in a cancellable way, so that it can be cancelled
  * while waiting to be dispatched.
  */
-internal fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>) =
+internal fun <T> (suspend () -> T).startCoroutineCancellable(completion: Continuation<T>) = runSafely(completion) {
     createCoroutineUnintercepted(completion).intercepted().resumeCancellable(Unit)
+}
 
 /**
  * Use this function to start coroutine in a cancellable way, so that it can be cancelled
  * while waiting to be dispatched.
  */
 internal fun <R, T> (suspend (R) -> T).startCoroutineCancellable(receiver: R, completion: Continuation<T>) =
-    createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellable(Unit)
+    runSafely(completion) {
+        createCoroutineUnintercepted(receiver, completion).intercepted().resumeCancellable(Unit)
+    }
+
+/**
+ * Runs given block and completes completion with its exception if it occurs.
+ * Rationale: [startCoroutineCancellable] is invoked when we are about to run coroutine asynchronously in its own dispatcher.
+ * Thus if dispatcher throws an exception during coroutine start, coroutine never completes, so we should treat dispatcher exception
+ * as its cause and resume completion.
+ */
+private inline fun runSafely(completion: Continuation<*>, block: () -> Unit) {
+    try {
+        block()
+    } catch (e: Throwable) {
+        completion.resumeWith(Result.failure(e))
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:Suppress("DeferredResultUnused")
+
+package kotlinx.coroutines
+
+import kotlinx.coroutines.channels.*
+import org.junit.*
+import org.junit.Test
+import org.junit.rules.*
+import kotlin.test.*
+
+class FailFastOnStartTest : TestBase() {
+
+    @Rule
+    @JvmField
+    public val timeout: Timeout = Timeout.seconds(5)
+
+    @Test
+    fun testLaunch() = runTest(expected = ::mainException) {
+        launch(Dispatchers.Main) {}
+    }
+
+    @Test
+    fun testLaunchLazy() = runTest(expected = ::mainException) {
+        val job = launch(Dispatchers.Main, start = CoroutineStart.LAZY) { fail() }
+        job.join()
+    }
+
+    @Test
+    fun testLaunchUndispatched() = runTest(expected = ::mainException) {
+        launch(Dispatchers.Main, start = CoroutineStart.UNDISPATCHED) {
+            yield()
+            fail()
+        }
+    }
+
+    @Test
+    fun testAsync() = runTest(expected = ::mainException) {
+        async(Dispatchers.Main) {}
+    }
+
+    @Test
+    fun testAsyncLazy() = runTest(expected = ::mainException) {
+        val job = async(Dispatchers.Main, start = CoroutineStart.LAZY) { fail() }
+        job.await()
+    }
+
+    @Test
+    fun testWithContext() = runTest(expected = ::mainException) {
+        withContext(Dispatchers.Main) {
+            fail()
+        }
+    }
+
+    @Test
+    fun testProduce() = runTest(expected = ::mainException) {
+        produce<Int>(Dispatchers.Main) { fail() }
+    }
+
+    @Test
+    fun testActor() = runTest(expected = ::mainException) {
+        actor<Int>(Dispatchers.Main) { fail() }
+    }
+
+    @Test
+    fun testActorLazy() = runTest(expected = ::mainException) {
+        val actor = actor<Int>(Dispatchers.Main, start = CoroutineStart.LAZY) { fail() }
+        actor.send(1)
+    }
+    
+    private fun mainException(e: Throwable): Boolean {
+        return e is IllegalStateException && e.message?.contains("Module with the Main dispatcher is missing") ?: false
+    }
+}