Incorrect partially moved value error check when pattern matching boxed structures.

The following code worked on 0.11 bu no longer works on master. Last known good nightly was August 1st.

struct Foo {
    a: Vec<u8>,
    b: Vec<u8>
}

fn main() {
    let foo = box Foo{a: Vec::new(), b: Vec::new()};
    let Foo { a: a, b: b } = *foo;
}

This will create the following error message:

<anon>:8:24: 8:25 error: use of partially moved value: `foo.b`
<anon>:8     let Foo { a: a, b: b } = *foo;
                                ^
<anon>:8:18: 8:19 note: `foo.a` moved here because it has type `collections::vec::Vec<u8>`, which is moved by default (use `ref` to override)
<anon>:8     let Foo { a: a, b: b } = *foo;

If Foo is not boxed this will function correctly.

struct Foo {
    a: Vec<u8>,
    b: Vec<u8>
}

fn main() {
    let foo = Foo{a: Vec::new(), b: Vec::new()};
    let Foo { a: a, b: b } = foo;
}

[goffrie]

As I commented on Reddit, it should be noted that moving explicitly out of foo (which should be inferred (?)) works around the bug:

struct Foo {
    a: Vec<u8>,
    b: Vec<u8>
}

fn move<T>(x: T) -> T { x }

fn main() {
    let foo = box Foo{a: Vec::new(), b: Vec::new()};
    let Foo { a: a, b: b } = *move(foo);
}

[zwarich]

This is fallout from #16102. The basic gist of this is that while the borrow checker was intentionally made less intelligent regarding the fields of a T in a Box<T>, it is also still stupid enough to treat let Foo { a: a, b: b } = foo; as two separate moves out of (*foo).a and (*foo).b.

If there is a DerefMove trait in the future that Box implements, then we can remove this special handling of Box and it will appear as a single move into a temporary, followed by two moves from the fields of the temporary, which the borrow checker can track in a field-sensitive manner.

[Gankra]

Borrowck is basically the typesystem, right?

Right?

[brson]

I'm untagging all pre-1.0 regressions to repurpose it for stable regressions.

[ticki]

This is still a problem.

[ticki]

And ... happened to stumple upon it again.

[ticki]

For anyone running into this issue: The problem can be solved by forcing a move using an identify function (for example, wrapping the value in {}).

[kennytm]

The identity function trick won't work nicely with a match when you want to keep the box in another arm:

#[derive(Debug)]
enum E {
    A(String, String),
    B(String, String),
}

impl E {
    fn f(self: Box<Self>) -> Box<Self> {
        match *self { // can't use `match {*self}`, otherwise can't use `self` below.
            E::A(..) => self,  
            E::B(a, b) => Box::new(E::B(b, a)), // <-- E0382 here
        }
    }
}

fn main() {
    println!("{:?}", Box::new(E::A("1".to_owned(), "2".to_owned())).f());
    println!("{:?}", Box::new(E::B("1".to_owned(), "2".to_owned())).f());
}

We could add an "indirection" as a workaround...

        match *self {
            E::A(..) => self,
            e => match e {              // workaround #16223
                E::B(a, b) => Box::new(E::B(b, a)), 
                _ => unreachable!(),    // ugly :(
            }
        }