Match element diagnostics improvements

[nichturner]

Addresses the Diagnostics section of #1307 after an experimental implementation of match elements was merged in #12021.

Standardized Terminology

Updated all references to match expression or match statement to be match element.

export global Palette {
    in-out property <color> primary: blue;

    match primary {
//  >error{A global component cannot have match elements}
        Colors.blue: Rectangle { background: orange; }
        Colors.red: Rectangle { background: green; }
        *: Rectangle { background: black; }
    }
//  <error{A global component cannot have match elements}
}

Zero Cases

A match element with zero cases will now produce a compiler error.

export component EmptyMatchElement {
    in-out property <int> xx: 0;
    match x {

    }
//  ^error{Expected at least one case}
    in-out property <int> yy: 20;
}

Duplicate Cases

A match element with two cases that resolve to the same value will now produce a compiler error.

export component DuplicateCaseWithInt {
    in-out property <int> xx: 0;

    match xx {
        0: Rectangle { }
        0: Rectangle { }
//      ^error{Duplicate case value}
        1: Rectangle { }
    }
}

export component DuplicateCaseWithCast {
    in-out property <int> xx: 0;

    match xx {
        2: Rectangle { }
        2.0: Rectangle { }
//      > <error{Duplicate case value}
        *: Rectangle { }
    }
}

Exhaustiveness

A type that can be covered completely (bool, enum) must do so, otherwise a * case is required. All other types require the * case.

enum Nums {
    one,
    two,
    three,
}

export component ExhaustiveEnum {
    in-out property <Nums> num: Nums.one;

    match num {
        Nums.one: Rectangle { }
        Nums.two: Rectangle { }
        Nums.three: Rectangle { }
    }
}

export component NonExhaustiveEnum {
    in-out property <Nums> num: Nums.one;

    match num {
//        >  <error{Non-exhaustive match on enum Nums: missing two, three}
        Nums.one: Rectangle { }
    }
}

export component NonExhaustiveInt {
    in-out property <int> num: 0;

    match num {
//        >  <error{Non-exhaustive match on int: a '*' case is required}
        0: Rectangle { }
        1: Rectangle { }
    }
}

export component WildcardInt {
    in-out property <int> num: 0;

    match num {
        0: Rectangle { }
        1: Rectangle { }
        *: Rectangle { }
    }
}

Unconditional Wildcard Cases

Added support for an empty match element with only a wildcard case to unconditionally render the wildcard case element.

export component UnconditionalWildcard{
   in-out property <int> num: 0;

    match num {
        *: Rectangle { }
    }
}

Single Error Outputs

Fixed issue with the same error message being reported multiple times when a * case is present.

export component CastWithWildcard {
    in property <int> num: 42;
    in property <int> num_2: 42;
    in property <string> str_num: "42";

    match num {
        42: Rectangle { }
        "42": Rectangle { }
//      >  <error{Cannot convert string to int}
        str_num: Rectangle { }
//      >     <error{Cannot convert string to int}
//      >     <^error{Cases must be literal values}
        *: Rectangle { }
    }
}

[ogoffart]

Please update the match-elements.mdx to reflect the changes.