Pattern matching on fixed length vectors should not be refutable

[brendanzab]

The length of fixed length vectors does not change, so a single pattern should be considered exhaustive.

Function argument destructuring:

fn foo<T>([x, y, z]: [T,..3]) -> (T, T, T) { (x, y, z) }

<anon>:7:19: 7:28 error: refutable pattern in function argument
<anon>:7          fn foo<T>([x, y, z]: [T,..3]) -> (T, T, T) { (x, y, z) }
                           ^~~~~~~~~

Let destructuring:

let [x, y, z] = [1, 2, 3]; 

<anon>:7:13: 7:22 error: refutable pattern in local binding
<anon>:7          let [x, y, z] = [1, 2, 3];
                     ^~~~~~~~~

Match patterns:

match [1, 2, 3] { [x, y, z] => (x, y, z) }

<anon>:7:9: 7:51 error: non-exhaustive patterns: vectors of length 0 not covered
<anon>:7          match [1, 2, 3] { [x, y, z] => (x, y, z) }
                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[jdm]

See also #5520.

[bstrie]

Additionally, all of these should work for any fixed length greater than zero:

fn foo<T>([head, ..tail]: [T,..3]) -> (T, [T]) { (head, tail) }

let [head, ..tail] = [1, 2, 3]; 

match [1, 2, 3] { [head, ..tail] => (head, tail) }

Also consider any other permutation where the .. is allowed, such as [first, ..middle, penultimate, ultimate] and so on (which would only work on sizes of 3 and greater).

[huonw]

We now consider fixed length vector patterns to be irrefutable in match, but not in let. The following compiles fine, but the commented out parts hit error: refutable pattern in local binding:

fn main() {
    let x = [1, 2, 3];

    match x {
        [_a, _b, _c] => {}
    }
    match x {
        [_a, .. _b] => {}
    }
    match x {
        [_a, .. _b, _c] => {}
    }

    /*
    let [_a, _b, _c] = x;
    let [_a, .. _b] = x;
    let [_a, .. _b, _c] = x;
    */
}

[ghost]

One way to go about this would be to check let refutability the same way exhaustiveness is checked in patterns. But I worry the perf impact might be significant.