Flow<T>.first operator throws NoSuchElementException where CancellationException must be thrown

[denyshorman]

Consider the following test

@Test
fun flowFirstOperatorTest() {
    assertDoesNotThrow {
        runBlocking(Dispatchers.Default) {
            launch {
                (0..10000).asFlow().flatMapMerge(Int.MAX_VALUE) {
                    channelFlow {
                        val v = channelFlow { send(1) }.first()
                        send(v)
                    }
                }.take(100)
            }
        }
    }
}

It is expected to take N elements and correctly finish the coroutine but actually it throws NoSuchElementException.

It happens because AbortFlowException, that is used inside first operator, extends CancellationException and if upstream flow is cancelled before calling collect, it must throw CancellationException instead of NoSuchElementException.

Test passes when AbortFlowException is extended from Throwable

@Test
fun flowFirstOperatorTest() {
    assertDoesNotThrow {
        runBlocking(Dispatchers.Default) {
            launch {
                (0..10000).asFlow().flatMapMerge(Int.MAX_VALUE) {
                    channelFlow {
                        val v = channelFlow { send(1) }.firstFixed()
                        send(v)
                    }
                }.take(100)
            }
        }
    }
}

object AbortFlowException : Throwable("", null, true, false)

suspend fun <T> Flow<T>.firstFixed(): T {
    var result: T? = null
    try {
        collect { value ->
            result = value
            throw AbortFlowException
        }
    } catch (e: AbortFlowException) {
        // Do nothing
    }

    if (result == null) throw NoSuchElementException("Expected at least one element")
    return result!!
}

This issue is relevant for firstOrNull operator and, perhaps, other similar ones.

[qwwdfsad]

Thanks for the report with self-contained repro!

Fixed using a more future-proof approach with checking the identity of the caught exception

[denyshorman]

@qwwdfsad, sounds good. Thanks!