/// Destination and optional payload type for one catch clause.

record CatchTarget: Copy {

    /// Block that receives the selected error.

    block: BlockId,

    /// Error type for a typed clause, or nil for a catch-all.

    errorType: ?resolver::Type,

}

/// Read a catch destination that the first lowering pass initialized.

fn catchTarget(targets: &[?CatchTarget], index: u32) -> CatchTarget {

    let target = targets[index] else panic "catchTarget: missing catch destination";

    return target;

}

    let mut targets: [?CatchTarget; MAX_CATCH_CLAUSES] = [nil; MAX_CATCH_CLAUSES];

        let block = try createBlock(self, "catch");

        addPredecessor(self, block, entry);

            set targets[i] = CatchTarget { block, errorType: errTy };

                target: *block,

            set targets[i] = CatchTarget { block, errorType: nil };

    let mut selectedDefault: ?BlockId = nil;

        set selectedDefault = catchTarget(&targets[..], idx).block;

        let block = try createBlock(self, "unreachable");

        addPredecessor(self, block, entry);

        set selectedDefault = block;

    let defaultTarget = selectedDefault else panic "lowerMultiCatch: missing default destination";

        let target = catchTarget(&targets[..], i);

        try switchToAndSeal(self, target.block);

            let errTy = target.errorType else panic "lowerMultiCatch: catch-all with binding";

//! returns: 0

//! Typed catch metadata retains every error payload across repeated dispatch.

/// Error payload 0.

union Error0: Copy { Value(u32) }

/// Error payload 1.

union Error1: Copy { Value(u32) }

/// Error payload 2.

union Error2: Copy { Value(u32) }

/// Error payload 3.

union Error3: Copy { Value(u32) }

/// Error payload 4.

union Error4: Copy { Value(u32) }

/// Error payload 5.

union Error5: Copy { Value(u32) }

/// Error payload 6.

union Error6: Copy { Value(u32) }

/// Error payload 7.

union Error7: Copy { Value(u32) }

/// Throw the selected payload or return a successful result.

fn dispatch(which: u32) -> u32 throws (Error0, Error1, Error2, Error3, Error4, Error5, Error6, Error7) {

    if which == 0 { throw Error0::Value(which + 10); }

    if which == 1 { throw Error1::Value(which + 10); }

    if which == 2 { throw Error2::Value(which + 10); }

    if which == 3 { throw Error3::Value(which + 10); }

    if which == 4 { throw Error4::Value(which + 10); }

    if which == 5 { throw Error5::Value(which + 10); }

    if which == 6 { throw Error6::Value(which + 10); }

    if which == 7 { throw Error7::Value(which + 10); }

    return 99;

}

/// Match every declared error type and retain its payload.

fn exhaustive(which: u32) -> u32 {

    let mut result: u32 = 0;

    set result = try dispatch(which) catch e as Error0 {

        let case Error0::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error1 {

        let case Error1::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error2 {

        let case Error2::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error3 {

        let case Error3::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error4 {

        let case Error4::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error5 {

        let case Error5::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error6 {

        let case Error6::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    } catch e as Error7 {

        let case Error7::Value(value) = e else panic "exhaustive: expected payload";

        return value;

    };

    return result;

}

/// Retain the typed payload or select the untyped fallback.

fn fallback(which: u32) -> u32 {

    return try dispatch(which) catch e as Error0 {

        let case Error0::Value(value) = e else panic "fallback: expected payload";

        return value;

    } catch {

        return 50;

    };

}

/// Exercise every catch destination, success, fallback, and repeated calls.

@default fn main() -> u32 {

    for repeat in 0..2 {

        for which in 0..8 { assert exhaustive(which) == which + 10; }

        assert exhaustive(8) == 99;

        assert fallback(0) == 10;

        assert fallback(7) == 50;

        assert fallback(8) == 99;

    }

    return 0;

}