Ignore exceptions thrown from Thread.UncaughtExceptionHandler (#4525)

Fixes #4516

Background
----------

Whenever an *uncaught* exception happens in a coroutine,
it gets reported to the `CoroutineExceptionHandler`.
See <https://kotlinlang.org/docs/exception-handling.html#coroutineexceptionhandler>.
However, if it's not installed, a platform-specific handler
is used.
On the JVM, this means invoking the thread's
`UncaughtExceptionHandler`, which logs the exception to the console
by default, but can be configured to do other things
(for example, on Android, it will crash the application).

Problem
-------

User-specified `UncaughtExceptionHandler` instances are allowed to
throw exceptions.
Java's documentation says so
(https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Thread.UncaughtExceptionHandler.html):
> Any exception thrown by this method will be ignored by the Java Virtual Machine.

This means a user is allowed to write a throwing
`UncaughtExceptionHandler`, and the caller has to deal with it.

In our implementation, however, we are simply invoking the
exception handler as a plain function, and if that function
throws an exception, we allow this exception to propagate
to the coroutine machinery, causing it to fail.

Solution
--------

To comply with the contract defined for `UncaughtExceptionHandler`,
we also ignore the exceptions thrown from there.

Author: dkhalanskyjb

kotlinx-coroutines-core/jvm/src/internal/CoroutineExceptionHandlerImpl.kt

@@ -28,7 +28,18 @@ internal actual fun ensurePlatformExceptionHandlerLoaded(callback: CoroutineExce
 internal actual fun propagateExceptionFinalResort(exception: Throwable) {
     // use the thread's handler
     val currentThread = Thread.currentThread()
-    currentThread.uncaughtExceptionHandler.uncaughtException(currentThread, exception)
+    val exceptionHandler = currentThread.uncaughtExceptionHandler
+    try {
+        exceptionHandler.uncaughtException(currentThread, exception)
+    } catch (_: Throwable) {
+        /* Do nothing.
+         * From https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Thread.UncaughtExceptionHandler.html :
+         * > Any exception thrown by this method will be ignored by the Java Virtual Machine.
+         *
+         * This means the authors of the thread exception handlers have the right to throw exceptions indiscriminately.
+         * We have no further channels for propagating the fatal exception, so we give up. */
+        val breakpoint = "Put a breakpoint here"
+    }
 }
 
 // This implementation doesn't store a stacktrace, which is good because a stacktrace doesn't make sense for this.

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

@@ -8,44 +8,68 @@ import kotlin.test.*
 
 class CoroutineExceptionHandlerJvmTest : TestBase() {
 
-    private val exceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
-    private lateinit var caughtException: Throwable
-
-    @Before
-    fun setUp() {
-        Thread.setDefaultUncaughtExceptionHandler({ _, e -> caughtException = e })
-    }
-
-    @After
-    fun tearDown() {
-        Thread.setDefaultUncaughtExceptionHandler(exceptionHandler)
-    }
-
     @Test
-    fun testFailingHandler() = runBlocking {
+    fun testThrowingHandler() = runBlocking {
         expect(1)
-        val job = GlobalScope.launch(CoroutineExceptionHandler { _, _ -> throw AssertionError() }) {
-            expect(2)
-            throw TestException()
+        val caughtException = catchingUncaughtException {
+            GlobalScope.launch(CoroutineExceptionHandler { _, _ -> throw TestException2() }) {
+                expect(2)
+                throw TestException()
+            }.join()
         }
-
-        job.join()
         assertIs<RuntimeException>(caughtException)
-        assertIs<AssertionError>(caughtException.cause)
+        assertIs<TestException2>(caughtException.cause)
         assertIs<TestException>(caughtException.suppressed[0])
 
         finish(3)
     }
 
     @Test
-    fun testLastDitchHandlerContainsContextualInformation() = runBlocking {
+    fun testLastResortHandlerContainsContextualInformation() = runBlocking {
         expect(1)
-        GlobalScope.launch(CoroutineName("last-ditch")) {
-            expect(2)
-            throw TestException()
-        }.join()
+        val caughtException = catchingUncaughtException {
+            GlobalScope.launch(CoroutineName("last-resort")) {
+                expect(2)
+                throw TestException()
+            }.join()
+        }
         assertIs<TestException>(caughtException)
-        assertContains(caughtException.suppressed[0].toString(), "last-ditch")
+        assertContains(caughtException.suppressed[0].toString(), "last-resort")
         finish(3)
     }
+
+    @Test
+    fun testThrowingUncaughtExceptionHandler() = runBlocking {
+        expect(1)
+        withUncaughtExceptionHandler({ _, e ->
+            // should be above the `expect` so that we can observe the failure
+            assertIs<TestException>(e)
+            expect(3)
+            throw TestException("will not be reported")
+        }) {
+            launch(Job()) {
+                expect(2)
+                throw TestException("will be passed to the uncaught exception handler")
+            }.join()
+        }
+        finish(4)
+    }
+}
+
+private inline fun catchingUncaughtException(action: () -> Unit): Throwable? {
+    var caughtException: Throwable? = null
+    withUncaughtExceptionHandler({ _, e -> caughtException = e }) {
+        action()
+    }
+    return caughtException
+}
+
+private inline fun <T> withUncaughtExceptionHandler(handler: Thread.UncaughtExceptionHandler, action: () -> T): T {
+    val exceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
+    Thread.setDefaultUncaughtExceptionHandler(handler)
+    try {
+        return action()
+    } finally {
+        Thread.setDefaultUncaughtExceptionHandler(exceptionHandler)
+    }
 }