Ensure that launch handles uncaught exception before another coroutine

that uses `join` on it resumes.

The launched coroutine handles uncaught exception in _completing_ state.

Fixes #208

Author: elizarov

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CommonJob.kt

@@ -87,6 +87,8 @@ internal expect open class JobSupport(active: Boolean) : Job {
 
     internal fun initParentJobInternal(parent: Job?)
     internal fun makeCompletingOnce(proposedUpdate: Any?, mode: Int): Boolean
+    internal open fun hasOnFinishingHandler(update: Any?): Boolean
+    internal open fun onFinishingInternal(update: Any?)
     internal open fun onCompletionInternal(state: Any?, mode: Int)
     internal open fun onStartInternal()
     internal open fun onCancellationInternal(exceptionally: CompletedExceptionally?)

common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonWithContextTest.kt

@@ -159,8 +159,8 @@ class CommonWithContextTest : TestBase() {
                 }
             } catch (e: Throwable) {
                 expect(7)
-                // make sure IOException, not CancellationException is thrown!
-                assertTrue(e is TestException)
+                // make sure TestException, not CancellationException is thrown!
+                assertTrue(e is TestException, "Caught $e")
             }
         }
         expect(2)

core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Builders.kt

@@ -188,9 +188,10 @@ private open class StandaloneCoroutine(
     private val parentContext: CoroutineContext,
     active: Boolean
 ) : AbstractCoroutine<Unit>(parentContext, active) {
-    override fun onCancellation(cause: Throwable?) {
+    override fun hasOnFinishingHandler(update: Any?) = update is CompletedExceptionally
+    override fun onFinishingInternal(update: Any?) {
         // note the use of the parent's job context below!
-        if (cause != null) handleCoroutineException(parentContext, cause)
+        if (update is CompletedExceptionally) handleCoroutineException(parentContext, update.exception)
     }
 }
 

core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt

@@ -1012,6 +1012,7 @@ internal actual open class JobSupport actual constructor(active: Boolean) : Job,
     private fun tryMakeCancelling(expect: Incomplete, list: NodeList, cause: Throwable?): Boolean {
         val cancelled = Cancelled(this, cause)
         if (!_state.compareAndSet(expect, Finishing(list, cancelled, false))) return false
+        onFinishingInternal(cancelled)
         onCancellationInternal(cancelled)
         notifyCancellation(list, cause)
         return true
@@ -1051,21 +1052,33 @@ internal actual open class JobSupport actual constructor(active: Boolean) : Job,
                 return COMPLETING_ALREADY_COMPLETING
             if (state is Finishing && state.completing)
                 return COMPLETING_ALREADY_COMPLETING
-            val child: Child = firstChild(state) ?: // or else complete immediately w/o children
-                if (updateState(state, proposedUpdate, mode)) return COMPLETING_COMPLETED else return@loopOnState
-            // must promote to list to correct operate on child lists
-            if (state is JobNode<*>) {
-                promoteSingleToNodeList(state)
-                return@loopOnState // retry
-            }
+            val child: Child? = firstChild(state) ?: // or else complete immediately w/o children
+                when {
+                    state !is Finishing && hasOnFinishingHandler(proposedUpdate) -> null // unless it has onFinishing handler
+                    updateState(state, proposedUpdate, mode) -> return COMPLETING_COMPLETED
+                    else -> return@loopOnState
+                }
+            val list = state.list ?: // must promote to list to correctly operate on child lists
+                when (state) {
+                    is Empty -> {
+                        promoteEmptyToNodeList(state)
+                        return@loopOnState // retry
+                    }
+                    is JobNode<*> -> {
+                        promoteSingleToNodeList(state)
+                        return@loopOnState // retry
+                    }
+                    else -> error("Unexpected state with an empty list: $state")
+                }
             // cancel all children in list on exceptional completion
             if (proposedUpdate is CompletedExceptionally)
-                child.cancelChildrenInternal(proposedUpdate.exception)
+                child?.cancelChildrenInternal(proposedUpdate.exception)
             // switch to completing state
             val cancelled = (state as? Finishing)?.cancelled ?: (proposedUpdate as? Cancelled)
-            val completing = Finishing(state.list!!, cancelled, true)
+            val completing = Finishing(list, cancelled, true)
             if (_state.compareAndSet(state, completing)) {
-                if (tryWaitForChild(child, proposedUpdate))
+                if (state !is Finishing) onFinishingInternal(proposedUpdate)
+                if (child != null && tryWaitForChild(child, proposedUpdate))
                     return COMPLETING_WAITING_CHILDREN
                 if (updateState(completing, proposedUpdate, mode = MODE_ATOMIC_DEFAULT))
                     return COMPLETING_COMPLETED
@@ -1157,6 +1170,16 @@ internal actual open class JobSupport actual constructor(active: Boolean) : Job,
      */
     internal actual open fun onCancellationInternal(exceptionally: CompletedExceptionally?) {}
 
+    /**
+     * @suppress **This is unstable API and it is subject to change.**
+     */
+    internal actual open fun hasOnFinishingHandler(update: Any?) = false
+
+    /**
+     * @suppress **This is unstable API and it is subject to change.**
+     */
+    internal actual open fun onFinishingInternal(update: Any?) {}
+
     /**
      * Override for post-completion actions that need to do something with the state.
      * @param mode completion mode.

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/Builders.kt

@@ -116,9 +116,10 @@ private open class StandaloneCoroutine(
         private val parentContext: CoroutineContext,
         active: Boolean
 ) : AbstractCoroutine<Unit>(parentContext, active) {
-    override fun onCancellation(cause: Throwable?) {
+    override fun hasOnFinishingHandler(update: Any?) = update is CompletedExceptionally
+    override fun onFinishingInternal(update: Any?) {
         // note the use of the parent's job context below!
-        if (cause != null) handleCoroutineException(parentContext, cause)
+        if (update is CompletedExceptionally) handleCoroutineException(parentContext, update.exception)
     }
 }
 

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt

@@ -724,6 +724,7 @@ internal actual open class JobSupport actual constructor(active: Boolean) : Job
     private fun makeCancellingList(list: NodeList, cause: Throwable?) {
         val cancelled = Cancelled(this, cause)
         state = Finishing(list, cancelled, false)
+        onFinishingInternal(cancelled)
         onCancellationInternal(cancelled)
         notifyCancellation(list, cause)
     }
@@ -761,23 +762,34 @@ internal actual open class JobSupport actual constructor(active: Boolean) : Job
                 return COMPLETING_ALREADY_COMPLETING
             if (state is Finishing && state.completing)
                 return COMPLETING_ALREADY_COMPLETING
-            val child: Child = firstChild(state) ?: run {
-                // or else complete immediately w/o children
-                updateState(proposedUpdate, mode)
-                return COMPLETING_COMPLETED
-            }
-            // must promote to list to correct operate on child lists
-            if (state is JobNode<*>) {
-                promoteSingleToNodeList(state)
-                continue@loop // retry
-            }
+            val child: Child? = firstChild(state) ?: // or else complete immediately w/o children
+                when {
+                    state !is Finishing && hasOnFinishingHandler(proposedUpdate) -> null // unless it has onCompleting handler
+                    else -> {
+                        updateState(proposedUpdate, mode)
+                        return COMPLETING_COMPLETED
+                    }
+                }
+            val list = state.list ?: // must promote to list to correctly operate on child lists
+                when (state) {
+                    is Empty -> {
+                        promoteEmptyToNodeList(state)
+                        continue@loop // retry
+                    }
+                    is JobNode<*> -> {
+                        promoteSingleToNodeList(state)
+                        continue@loop // retry
+                    }
+                    else -> error("Unexpected state with an empty list: $state")
+                }
             // cancel all children in list on exceptional completion
             if (proposedUpdate is CompletedExceptionally)
-                child.cancelChildrenInternal(proposedUpdate.exception)
+                child?.cancelChildrenInternal(proposedUpdate.exception)
             // switch to completing state
-            val completing = Finishing(state.list!!, (state as? Finishing)?.cancelled, true)
+            val completing = Finishing(list, (state as? Finishing)?.cancelled, true)
             this.state = completing
-            if (tryWaitForChild(child, proposedUpdate))
+            if (state !is Finishing) onFinishingInternal(proposedUpdate)
+            if (child != null && tryWaitForChild(child, proposedUpdate))
                 return COMPLETING_WAITING_CHILDREN
             updateState(proposedUpdate, mode = MODE_ATOMIC_DEFAULT)
             return COMPLETING_COMPLETED
@@ -860,6 +872,16 @@ internal actual open class JobSupport actual constructor(active: Boolean) : Job
      */
     internal actual open fun onCancellationInternal(exceptionally: CompletedExceptionally?) {}
 
+    /**
+     * @suppress **This is unstable API and it is subject to change.**
+     */
+    internal actual open fun hasOnFinishingHandler(update: Any?) = false
+
+    /**
+     * @suppress **This is unstable API and it is subject to change.**
+     */
+    internal actual open fun onFinishingInternal(update: Any?) {}
+
     /**
      * Override for completion actions that need to do something with the state.
      * @param mode completion mode.