Is there any meaningful difference between manually cancelling a coroutine and throwing CancellationException?

[kevincianfarini]

I have a flow that, when it encounters a certain value, should terminate exceptionally. For specific reasons this flow should be cancelled and not be a specific exception that should be otherwise handled.

This raised a certain question for me: Is there any meaningful difference between cancelling a coroutine manually versus throwing cancellation exception? Eg.

fun Flow.explicitWithInternalScope() = flow {
  coroutineScope {
    collect { upstreamValue -> 
      when (upstreamValue) {
        Good -> emit(upstreamValue)
        Bad -> cancel(/* omitted */)
      }
    }
  }
}

fun Flow.explicitCancelsDirectParent() = flow {
  collect { upstreamValue -> 
    when (upstreamValue) {
      Good -> emit(upstreamValue)
      Bad -> currentCoroutineContext().cancel(/* omitted */)
    }
  }
}

fun Flow.implicit() = flow {
  collect { upstreamValue -> 
    when (upstreamValue) {
      Good -> emit(upstreamValue)
      Bad -> throw CancellationException(/* omitted */)
    }
  }
}

My suspicion is that these will differ in the following ways:

Flow.explicitWithInternalScope

This will create a new job internal to the flow and cancel that job. If this job gets cancelled it will bubble upwards as you'd expect, but won't cancel sibling coroutines in the event that a parent is a supervisor.

Flow.explicitCancelsDirectParent

Similar to the above, however in the event that the scope this coroutine is running in is a supervisor it will be cancelled. This might come as a surprise to consumers of this flow.

Flow.implicit

I am unsure about this one and it's what prompted this discussion. Will throwing CancellationException still progress a job through its expected state machine? Eg: Active -> Cancelling -> Cancelled. Is this potentially dangerous in any way? Are the Job.cancel functions mostly meant to cancel work in a top-down approach, which either the implicit or explicit approached can be used to cancel from the bottom up?