Nested slice pattern incorrectly considered irrefutable

[eefriedman]

Testcase:

#![feature(slice_patterns)]
fn main() { let x: &[String] = &[]; let [[ref _a, _b..]..] = x; }

This clearly shouldn't type-check, but currently compiles without any error.

[oli-obk]

This is very bad:

#![feature(slice_patterns)]
fn main() {
    let x: &[u32] = &[];
    let [[a, b..]..] = x;
    println!("{:08x}", a);
    for x in b.iter().take(30) {
        println!("{:08x}", x);
    }
}

0000000a
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000020
00000003
00000008
00000000
00000003
00000000
00000000
00000000
00000000
00000000
00000008
00000000
74697261
74656d68
6f206369
61726570
6e6f6974
65766f20
6f6c6672
00646577
6d6f682f
75722f65
75627473

[TheNeikos]

If I understand correctly this reads unitialized memory? Or rather, not owned memory?

[bluss]

@TheNeikos yes. Fortunately it depends on a feature marked unstable.

[TheNeikos]

@bluss Alright

[eefriedman]

This is outdated since the slice pattern rewrite. Filed #35077 as a followup.

[eefriedman]

Wait, nevermind, this is still a problem; revised testcase:

#![feature(slice_patterns)]
fn main() {
    let x: &[u32] = &[];
    let (a, b) = match x { &[[a, ref b..]..] => (a, b) };
    println!("{:08x}", a);
    for x in b.iter().take(30) {
        println!("{:08x}", x);
    }
}

[eefriedman]

Related miscompile:

#![feature(slice_patterns)]
fn main() {
    let x: &[String] = &[];
    match x {
        &[[ref b..]..] => { println!("Fun{}{}", b.len()); }
    }
}

MIR ICE:

#![feature(slice_patterns)]
fn main() { let x: &[i32] = &[]; let &[[_a, ref _b..]..] = x; }

[arielb1]

I want to figure out our nested slice pattern story.

[nikomatsakis]

@arielb1 can you clarify what are the thorny cases and where things get confusing?