/// Classify a match prong and reject duplicate catch-alls.

/// Record whether lowering can omit the prong's pattern test.

fn checkMatchProng 'arena (

    state: &mut MatchState

) throws (ResolveError) {

            case ast::ProngArm::Binding(_) => {

                // For optionals, a binding matches only a present value.

                set isCatchAll = not isOptionalType(subjectTy);

            },

            case ast::ProngArm::Else => set isCatchAll = true,

    let mut state = MatchState { catchAll: false, isConst: false };

        try checkMatchProng(self, prongNode, prong, subjectTy, &mut state);

    if not state.catchAll {

        try checkMatchProng(self, prongNode, prong, subjectTy, &mut state);

        set matchType = try visitMatchProng(self, prongNode, prong, subjectTy, matchType, matchBy);

        try checkMatchProng(self, prongNode, prong, subjectTy, &mut state);

        set matchType = try visitMatchProng(self, prongNode, prong, subjectTy, matchType, matchBy);

/// Expected lowering metadata for a resolved match.

record MatchMetadataCase: Copy {

    /// Complete source program with a function named f.

    source: *[u8],

    /// Bit set when lowering can omit a prong's pattern test.

    catchAllMask: u32,

    /// Whether scalar cases can use switch lowering.

    isConst: bool,

}

/// Guards and subject types determine unconditional-prong metadata.

@test unsafe fn testMatchCatchAllMetadata() throws (testing::TestError) {

    let cases = [

        MatchMetadataCase { source: "fn f(x: u32) { match x { case 1 => {}, else => {} } }", catchAllMask: 2, isConst: true },

        MatchMetadataCase { source: "fn f(x: u32) { match x { n if n > 0 => {}, case _ => {} } }", catchAllMask: 2, isConst: false },

        MatchMetadataCase { source: "fn f(x: u32) { match x { case _ if x > 0 => {}, n => {} } }", catchAllMask: 2, isConst: false },

        MatchMetadataCase { source: "fn f(x: u32) { match x { n => {} } }", catchAllMask: 1, isConst: false },

        MatchMetadataCase { source: "fn f(x: [[u32; 2]; 2]) { match x { case [[1, a], [b, c]] => {}, case [[a, b], [c, d]] => {} } }", catchAllMask: 2, isConst: false },

        MatchMetadataCase { source: "union U: Copy { A, B } fn f(x: U) { match x { case U::A => {}, else => {} } }", catchAllMask: 2, isConst: false },

        MatchMetadataCase { source: "fn f(x: ?u32) { match x { n => {}, case nil => {} } }", catchAllMask: 2, isConst: false },

        MatchMetadataCase { source: "fn f(x: ?u32) { match x { case _ if false => {}, else => {} } }", catchAllMask: 2, isConst: false },

        MatchMetadataCase { source: "fn f(x: ?u32) { match x { case _ => {} } }", catchAllMask: 1, isConst: false },

        MatchMetadataCase { source: "fn f(x: bool) { match x { case true => {}, case false => {} } }", catchAllMask: 2, isConst: true },

    ];

    for item in cases {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, item.source);

            try expectNoErrors(&result);

            let body = try getFnBody(&res, result.root, "f");

            let node = body.statements[0];

            let case ast::NodeValue::Match(sw) = node.value else throw testing::TestError::Failed;

            for prong, i in sw.prongs {

                assert super::isProngCatchAll(&res, prong) == ((item.catchAllMask & (1 << i)) <> 0);

            }

            assert super::isMatchConst(&res, node) == item.isConst;

        }

    }

}

/// Duplicate unconditional arms are rejected for each match subject category.

@test unsafe fn testMatchDuplicateCatchAll() throws (testing::TestError) {

    for source in [

        "fn f(x: u32) { match x { case _ => {}, else => {} } }",

        "fn f(x: u32) { match x { n => {}, case _ => {} } }",

        "fn f(x: [[u32; 2]; 2]) { match x { case [[a, b], [c, d]] => {}, else => {} } }",

        "union U: Copy { A, B } fn f(x: U) { match x { n => {}, else => {} } }",

        "fn f(x: ?u32) { match x { case _ => {}, else => {} } }",

    ] {

        let mut arena = testArena();

        let storage: 'test = &mut arena in {

            let mut res = testResolver(storage);

            let result = try resolveProgramStr(&mut res, source);

            try expectErrorKind(&result, super::ErrorKind::DuplicateCatchAll);

        }

    }

}

//! returns: 0

//! Guarded patterns retain their fallback paths.

/// Select a guarded nested array pattern or its unconditional fallback.

fn matrix(values: [[u32; 2]; 2]) -> u32 {

    match values {

        case [[a, b], [c, d]] if a == 1 => return b + c + d,

        case [[a, b], [c, d]] => return a,

    }

}

/// An optional binding selects only a present value.

fn optional(value: ?u32) -> u32 {

    match value {

        n if n > 10 => return 1,

        n => return n,

        case nil => return 20,

    }

}

/// A wildcard guard permits both optional values to reach the fallback.

fn guarded(value: ?u32, accept: bool) -> u32 {

    match value {

        case _ if accept => return 3,

        else => return 4,

    }

}

/// Match metadata selects the same paths for every guard outcome.

@default fn main() -> u32 {

    assert matrix([[1, 2], [3, 4]]) == 9;

    assert matrix([[5, 2], [3, 4]]) == 5;

    assert optional(nil) == 20;

    assert optional(7) == 7;

    assert optional(11) == 1;

    assert guarded(nil, false) == 4;

    assert guarded(nil, true) == 3;

    assert guarded(7, false) == 4;

    assert guarded(7, true) == 3;

    return 0;

}