Memory unsafety using & bindings more than one level deep when destructuring

[pythonesque]

This segfaults.

// Note: you can also replicate this with this function signature.
// fn foo<'a, 'b, 'c>(mut pair: (&'c mut &'a mut Vec<Option<String>>, &'b mut Vec<&'a mut Option<String>>)) {
//     let mut pair = (&mut a, &mut b);
// }

fn main() {
    let mut a = Vec::new();
    let mut a = &mut a;
    let mut b = Vec::new();
    for _ in range(0u8, 9) {
        //foo((&mut a, &mut b));
        // Correctly complains if you do: let (ref mut a, ref mut b) = (&mut a, &mut b);
        // Also correctly complains in Rust 0.12.
        let (&ref mut a, ref mut b) = (&mut a, &mut b);
        a.push(Some("".to_string()));
        let index = a.len() - 1;
        let data = a.as_mut_slice().get_mut(index).unwrap();
        b.push(data);
    }
    println!("{}", b);
}

[nikomatsakis]

cc me

[nikomatsakis]

Nominating.

[pythonesque]

Simplified test case (no unsafe code):

fn main() {
    let a = 0u8;
    let mut a = Some(&a);
    if let (&Some(ref b),) = (&a,) {
        a = None;
        println!("{}, {}", a, b);
    }
}

This seems to be an issue with tuple patterns specifically. I can't get it to happen if I try the same thing without one. The behavior suggests to me that borrowck does not consider &a to borrow a in such patterns.

[pythonesque]

Actually, I can make it happen for tuple structs as well:

fn main() {
    struct Foo<'a, 'b: 'a>(&'a Option<&'b u8>);
    let a = 0u8;
    let mut a = Some(&a);
    if let Foo(&Some(ref b)) = Foo(&a) {
        a = None;
        println!("{}, {}", a, b);
    }
}

and regular structs:

fn main() {
    struct Foo<'a, 'b: 'a> { data: &'a Option<&'b u8> };
    let a = 0u8;
    let mut a = Some(&a);
    if let Foo { data: &Some(ref b) } = (Foo { data: &a }) {
        a = None;
        println!("{}, {}", a, b);
    }
}

and even enum variants:

fn main() {
    struct Foo<'a, 'b: 'a>(&'a Option<&'b u8>);
    let a = 0u8;
    let mut a = Some(&a);
    if let Foo::Foo(&Some(ref b)) = Foo::Foo(&a) {
        a = None;
        println!("{}, {}", a, b);
    }
}

[nikomatsakis]

Got a fix coming.