expression: THROW
text: throw Exception()

fun test() {
    try {
        throw Exception()
    } finally {
        <expr>9</expr>
    }

        if (virtualFile == null) {
            throw KotlinExceptionWithAttachments("Cannot find a KtModule for a non-physical file")
                .withPsiAttachment("containingFile", containingFile)
                .withAttachment("contextualModule", contextualModule?.asDebugString())
        }

        return allKtModules.firstOrNull { module -> virtualFile in module.contentScope }

// WITH_STDLIB

fun test(a: Int): Int {
    val b: Int = a + 10
    for (n in 1..b) {
        <expr>if (n > 5) throw Exception("")
        if (a + n > b) break
        println(b - n)</expr>
    }

// WITH_STDLIB

fun test() {
    consume(1)
    <expr>try {
        dangerous()
    } catch (e: FooException) {
        consume(e.message?.length ?: 0)
        throw e
    }</expr>
}

fun consume(n: Int) {}

@Throws(FooException::class)
fun dangerous(): String {
    return "foo"
}

internal class KaFe10DataFlowInfoProvider(override val analysisSession: KaSession) : KaDataFlowInfoProvider() {
    override fun getExitPointSnapshot(statements: List<KtExpression>): KaDataFlowExitPointSnapshot {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

    override fun iterator(): Iterator<KaAnnotation> = withValidityAssertion {
        return Collections.emptyIterator()
    }

    override fun get(index: Int): KaAnnotation = withValidityAssertion {
        throw IndexOutOfBoundsException("Index $index out of bounds")
    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return false
    }

     *
     * **Note!** This is a conservative check, not a control-flow analysis.
     * E.g. `x` in the following example *is possibly used*, even though the
     * value is never consumed at runtime.
     *   - `x + try { throw Exception() } finally { return }`
     *
     */
    public fun KtExpression.isUsedAsExpression(): Boolean =
        withValidityAssertion { analysisSession.expressionInfoProvider.isUsedAsExpression(this) }
}

            is KaFirAnonymousObjectSymbol -> processOverrides(containingDeclaration, callableSymbol, process)
            else -> throw IllegalStateException("Expected $containingDeclaration to be a KtFirNamedClassOrObjectSymbol or KtFirAnonymousObjectSymbol")
        }
    }

    private inline fun processOverrides(

            // when is an `else`.
            is KtWhenExpression ->
                parent.subjectExpression == child && parent.entries.firstOrNull()?.isElse == false

            // Throw expressions use the expression thrown.
            is KtThrowExpression ->
                parent.thrownExpression == child

            // Body and catch blocks of try-catch expressions are used if the try-catch itself