Something seems missing here. Doesn't this produce a binding for the slice? If so, don't we have to extend candidate.bindings?

Maybe try an example that actually uses the binding? e.g.

let [foo..] = s;
println!("{:?}", foo);

Thank you for you review! I tried the example, and it died with segmentation fault. So yes, we need to extend candidate.bindings. I will update this PR to do so.

Can we update this test to actually use xs?

For example:

fn foo(s: &[i32]) -> &[i32] {
    let &[ref s1..] = s;
    s1
}

fn main() {
    let x = [1, 2, 3];
    let y = foo(&x);
    assert_eq!(y, &[1, 2, 3]);
}

Oops, I forgot to do this.

Huh, so, something here makes me a bit nervous. Why not invoke the helper prefix_slice_suffix? For example:

self.prefix_slice_suffix(
    &mut candidate.match_pairs,
    match_pair.place,
    prefix,
    slice,
    suffix,
);

that helper is more general than strictly needed, but I think it is sure to do the right thing, or at least we can do the wrong thing all in the same code. =)

(In this particular case, the main difference would be that the Place would include a Subslice projection, I think, which may not be needed, but I still think i'd rather go through the helper.)

Thoughts?

In prefix_slice_suffix(), we have

        if let Some(subslice_pat) = opt_slice {
            let subslice = place.clone().elem(ProjectionElem::Subslice {
                from: prefix.len() as u32,
                to: suffix.len() as u32
            });
            match_pairs.push(MatchPair::new(subslice, subslice_pat));
        }

so ProjectionElem::Subslice.to is set to suffix.len() which is 0 in this case.

Doc comment on Subslice in librustc/mir/mod.rs says:

    /// These indices are generated by slice patterns.
    ///
    /// slice[from:-to] in Python terms.
    Subslice {
        from: u32,
        to: u32,
    },

In Python, slice[from:-0] will be an empty list. This is why I avoided using prefix_slice_suffix().

However, it turns that setting to to 0 is actually equivalent to slice[from:] in Python term. So I agree that using prefix_slice_suffix() is better here.