Language: Kotlin · Versions: Kotlin 2.1.0 (kotlinx-coroutines-core:1.9.0)
The problem
I wrote a Flow producer that wraps an emit(...) call inside runCatching { ... } so it can log or recover from transient errors. When the downstream consumer uses .take(1) or .first(), those terminal operators cancel the upstream flow by throwing an internal AbortFlowException (a subclass of CancellationException) from emit(). Because runCatching catches Throwable—including CancellationException—my producer swallows the AbortFlowException and continues executing remaining iterations instead of stopping after the first item!
Minimal example
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun numbers(): Flow<Int> = flow {
for (i in 1..3) {
runCatching {
println("Emitting $i")
emit(i) // .first() throws AbortFlowException (a CancellationException) here!
}.onFailure { e ->
println("Caught failure during emit($i): ${e::class.simpleName}")
}
}
}
fun main() = runBlocking {
val first = numbers().first()
println("Result: $first")
}
Expected
Emitting 1, then immediately Result: 1 (iterations 2 and 3 should never run).
What happens instead
Emitting 1
Caught failure during emit(1): AbortFlowException
Emitting 2
Caught failure during emit(2): AbortFlowException
Emitting 3
Caught failure during emit(3): AbortFlowException
Result: 1
Because emit(1) threw AbortFlowException to short-circuit the flow { ... } builder and runCatching swallowed it, the loop kept running and tried to emit 2 and 3 into an already-aborted collector!
Why does runCatching catch CancellationException in Kotlin Coroutines, how does that violate Flow's exception transparency (checkContext), and what is the idiomatic helper to replace runCatching in suspend functions and Flow builders?
Fix: keep emit out of the catch, or rethrow cancellation
fun numbers(): Flow<Int> = flow {
for (i in 1..3) {
val v = runCatching { compute(i) } // only the risky producer code
.onFailure { if (it is CancellationException) throw it; log(it) }
.getOrNull() ?: continue
emit(v) // outside any catch
}
}
If the emit has to stay inside the try, use a cancellation-aware helper:
inline fun <R> runCatchingCancellable(block: () -> R): Result<R> =
try { Result.success(block()) }
catch (e: CancellationException) { throw e }
catch (e: Throwable) { Result.failure(e) }
Why
runCatchingis in the Kotlin stdlib, which knows nothing about coroutines. It catches everyThrowable, andCancellationExceptionis one. This is a long-standing complaint, and as far as I know neither the stdlib nor kotlinx.coroutines 1.9.0 ships a cancellation-safe variant, so you write your own, as above. I haven't checked the issue tracker for the current status.first()andtake(1)stop the upstream by throwing anAbortFlowException, which extendsCancellationException. It is a control-flow signal, so it has to reach the collector that owns it. Swallowing it breaks that contract.- Flow's exception transparency is enforced in
SafeCollector. If a downstreamemitthrows, the collector records that. A lateremitfrom the sameflow {}then fails with anIllegalStateExceptionthat starts "Flow exception transparency is violated".
Your output is probably not what you posted
I'm reasoning from the SafeCollector source and haven't run your snippet. On my reading, the failures for iterations 2 and 3 should print IllegalStateException, not AbortFlowException. The second emit never reaches the downstream collector, because the transparency check throws first, and runCatching swallows that too.
The Result: 1 you saw is consistent with this. If the second emit did reach the collector, first() would not stay at 1.
To settle it, print e.message in onFailure. Also check SafeCollector.kt in 1.9.0 for exceptionTransparencyViolated.
Rule of thumb
Never put emit or any other suspension point inside a blanket catch (Throwable). Catch around the code that can fail, or use the catch operator, which is upstream-only. Anywhere you do catch broadly in suspend code, rethrow CancellationException.