Stylistic updates to exception handling rework

Author: elizarov

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

@@ -25,25 +25,21 @@ internal expect fun handleCoroutineExceptionImpl(context: CoroutineContext, exce
 public fun handleCoroutineException(context: CoroutineContext, exception: Throwable, caller: Job? = null) {
     // if exception handling fails, make sure the original exception is not lost
     try {
-
         // Ignore CancellationException (they are normal ways to terminate a coroutine)
         if (exception is CancellationException) {
             return
         }
-
         // If parent is successfully cancelled, we're done, it is now its responsibility to handle the exception
         val parent = context[Job]
         // E.g. actor registers itself in the context, in that case we should invoke handler
         if (parent !== null && parent !== caller && parent.cancel(exception)) {
             return
         }
-
         // If not, invoke exception handler from the context
         context[CoroutineExceptionHandler]?.let {
             it.handleException(context, exception)
             return
         }
-
         // If handler is not present in the context, fallback to the global handler
         handleCoroutineExceptionImpl(context, exception)
     } catch (handlerException: Throwable) {

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

@@ -154,7 +154,7 @@ public interface Job : CoroutineContext.Element {
      * or it's being cancelled and given [cause] was successfully received by the job and will be properly handled, `false` otherwise.
      *
      * If this method returned `false`, then caller is responsible for handling [cause].
-     * If job is already completed, method returns `false`
+     * If job is already completed, method returns `false`.
      *
      * When cancellation has a clear reason in the code, an instance of [CancellationException] should be created
      * at the corresponding original cancellation site and passed into this method to aid in debugging by providing

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

@@ -12,15 +12,12 @@ fun main(args: Array<String>) = runBlocking {
         println("Throwing exception from launch")
         throw IndexOutOfBoundsException() // Will be printed to the console by Thread.defaultUncaughtExceptionHandler
     }
-
     job.join()
     println("Joined failed job")
-
     val deferred = async {
         println("Throwing exception from async")
         throw ArithmeticException() // Nothing is printed, relying on user to call await
     }
-
     try {
         deferred.await()
         println("Unreached")

core/kotlinx-coroutines-core/test/guide/example-exceptions-01.kt

@@ -8,15 +8,14 @@ package kotlinx.coroutines.experimental.guide.exceptions02
 import kotlinx.coroutines.experimental.*
 
 fun main(args: Array<String>) = runBlocking {
-    val handler = CoroutineExceptionHandler { _, exception -> println("Caught $exception") }
-
+    val handler = CoroutineExceptionHandler { _, exception -> 
+        println("Caught $exception") 
+    }
     val job = launch(handler) {
         throw AssertionError()
     }
-
     val deferred = async(handler) {
         throw ArithmeticException() // Nothing will be printed, relying on user to call deferred.await()
     }
-
     joinAll(job, deferred)
 }

core/kotlinx-coroutines-core/test/guide/example-exceptions-02.kt

@@ -17,14 +17,12 @@ fun main(args: Array<String>) = runBlocking {
                 println("Child is cancelled")
             }
         }
-
         yield()
         println("Cancelling child")
         child.cancel()
         child.join()
         yield()
         println("Parent is not cancelled")
     }
-
     job.join()
 }

core/kotlinx-coroutines-core/test/guide/example-exceptions-03.kt

@@ -9,27 +9,26 @@ import kotlinx.coroutines.experimental.*
 import kotlin.coroutines.experimental.*
 
 fun main(args: Array<String>) = runBlocking {
-     val handler = CoroutineExceptionHandler { _, exception -> println("Caught $exception") }
-   
-       val job = launch(handler) {
-           val child1 = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
-               try {
-                   delay(Long.MAX_VALUE)
-               } finally {
-                   withContext(NonCancellable) {
-                       println("Children are cancelled, but exception is not handled until children are terminated completely")
-                       delay(100)
-                       println("Last child finished its non cancellable block")
-                   }
-               }
-           }
-   
-           val child2 = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
-               delay(10)
-               println("Child throws an exception")
-               throw ArithmeticException()
-           }
-       }
-   
-       job.join()
+    val handler = CoroutineExceptionHandler { _, exception -> 
+        println("Caught $exception") 
+    }
+    val job = launch(handler) {
+        val child1 = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+            try {
+                delay(Long.MAX_VALUE)
+            } finally {
+                withContext(NonCancellable) {
+                    println("Children are cancelled, but exception is not handled until all children terminate")
+                    delay(100)
+                    println("Last child finished its non cancellable block")
+                }
+            }
+        }
+        val child2 = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+            delay(10)
+            println("Second child throws an exception")
+            throw ArithmeticException()
+        }
+    }
+    job.join()
 }

core/kotlinx-coroutines-core/test/guide/example-exceptions-04.kt

@@ -7,29 +7,25 @@ package kotlinx.coroutines.experimental.guide.exceptions05
 
 import kotlinx.coroutines.experimental.*
 import kotlinx.coroutines.experimental.exceptions.*
-import java.io.*
 import kotlin.coroutines.experimental.*
+import java.io.*
 
 fun main(args: Array<String>) = runBlocking {
     val handler = CoroutineExceptionHandler { _, exception ->
-           println("Caught $exception with suppressed ${exception.suppressed().contentToString()}")
-       }
-   
-       val job = launch(handler + coroutineContext, parent = Job()) {
-           launch(coroutineContext, start = CoroutineStart.ATOMIC) {
-                try {
-                    delay(Long.MAX_VALUE)
-                } finally {
-                    throw ArithmeticException()
-                }
-           }
-           
-           launch(coroutineContext) {
-               throw IOException()
-           }
-   
-           delay(Long.MAX_VALUE)
-       }
-   
-       job.join()
+        println("Caught $exception with suppressed ${exception.suppressed().contentToString()}")
+    }
+    val job = launch(handler + coroutineContext, parent = Job()) {
+        launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+            try {
+                delay(Long.MAX_VALUE)
+            } finally {
+                throw ArithmeticException()
+            }
+        }
+        launch(coroutineContext) {
+            throw IOException()
+        }
+        delay(Long.MAX_VALUE)
+    }
+    job.join()
 }

core/kotlinx-coroutines-core/test/guide/example-exceptions-05.kt

@@ -6,30 +6,27 @@
 package kotlinx.coroutines.experimental.guide.exceptions06
 
 import kotlinx.coroutines.experimental.*
-import java.io.*
 import kotlin.coroutines.experimental.*
+import java.io.*
 
 fun main(args: Array<String>) = runBlocking {
-  val handler = CoroutineExceptionHandler { _, exception ->
-         println("Caught original $exception")
-     }
- 
-     val job = launch(handler) {
-         val inner = launch(coroutineContext) {
-             launch(coroutineContext) {
-                 launch(coroutineContext) {
-                     throw IOException()
-                 }
-             }
-         }
- 
-         try {
-             inner.join()
-         } catch (e: JobCancellationException) {
-             println("Rethrowing JobCancellationException with original cause")
-             throw e
-         }
-     }
- 
-     job.join()
+    val handler = CoroutineExceptionHandler { _, exception ->
+        println("Caught original $exception")
+    }
+    val job = launch(handler) {
+        val inner = launch(coroutineContext) {
+            launch(coroutineContext) {
+                launch(coroutineContext) {
+                    throw IOException()
+                }
+            }
+        }
+        try {
+            inner.join()
+        } catch (e: JobCancellationException) {
+            println("Rethrowing JobCancellationException with original cause")
+            throw e
+        }
+    }
+    job.join()
 }

core/kotlinx-coroutines-core/test/guide/example-exceptions-06.kt

@@ -1,7 +1,7 @@
 // This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
 package kotlinx.coroutines.experimental.guide.test
 
-import org.junit.*
+import org.junit.Test
 
 class GuideTest {
 
@@ -297,8 +297,8 @@ class GuideTest {
     @Test
     fun testKotlinxCoroutinesExperimentalGuideExceptions04() {
         test("KotlinxCoroutinesExperimentalGuideExceptions04") { kotlinx.coroutines.experimental.guide.exceptions04.main(emptyArray()) }.verifyLines(
-            "Child throws an exception",
-            "Children are cancelled, but exception is not handled until children are terminated completely",
+            "Second child throws an exception",
+            "Children are cancelled, but exception is not handled until all children terminate",
             "Last child finished its non cancellable block",
             "Caught java.lang.ArithmeticException"
         )