An exception in `ThreadContextElement.updateThreadContext` is impossible to handle properly

[gregsh]

import kotlinx.coroutines.*
import kotlin.coroutines.CoroutineContext

fun main() {
    Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
        throwable.printStackTrace() // does not work
    }
    runBlocking(Dispatchers.Default) {
        try {
            withContext(CoroutineName("any")) {
                // try
                withContext(ContextElement(10)) {
                    println("Success!")
                }
                //} catch (e: Exception) {
                //    e.printStackTrace() // the only catch that works
                //}

        }
        } catch (e: Exception) {
            e.printStackTrace() // this catch is not called
        }
    }
}

private val threadLocal = ThreadLocal<Int>()

private class ContextElement(val value: Int) : ThreadContextElement<Int> {
    companion object : CoroutineContext.Key<ContextElement>

    override val key: CoroutineContext.Key<*> get() = ContextElement
    override fun restoreThreadContext(context: CoroutineContext, oldState: Int) {
        threadLocal.set(oldState)
    }

    override fun updateThreadContext(context: CoroutineContext): Int {
        val oldState = threadLocal.get()
        threadLocal.set(value)
        return oldState // <--- implicit NPE here
    }
}

[murfel]

Chatted with Greg privately, I confirm that it is not a good developer experience, and requires a review.

At the very least, the documentation needs to state that the app can hang, not only crash. Also, we should consider a DelicateCoroutineApi opt-in.

As a separate measure, we could introduce an inspection to prompt casting T! (here from java's thread local) to either T or T? to enabling Kotlin type system support.