Destructuring boxes into multiple mutable references seems broken

[ben0x539]

This fails with "cannot mutably borrow more than once" errors

fn push(mut node: Box<(i32, i32)>) {
    let (ref mut left, ref mut right) = *node;
}

Same here:

fn push(mut node: Box<(i32, i32)>) {
    let box (ref mut left, ref mut right) = node;
}

This works:

fn push(mut node: Box<(i32, i32)>) {
    let (ref mut left, ref mut right) = *&mut *node;
}

This also works:

fn push(node: &mut (i32, i32)) {
    let (ref mut left, ref mut right) = *node;
}

Same behavior with structs instead of tuples. Boxes are weird, destructuring into mutable borrows is weird, so I have no idea what is going on there.

[jethrogb]

#![feature(box_patterns)]

box pattern

There. Now other people can find this bug.

[aidanhs]

More keywords: match, if let.
(no, they don't work either)

Two workarounds are to either a) use *&mut *x or b) bring std::ops::DerefMut in and use *x.deref_mut():

use std::ops::DerefMut;
fn main() {
    let mut x = Box::new((1, 2));
    { let (ref mut a, ref mut b) = *&mut *x; }
    { let (ref mut a, ref mut b) = *x.deref_mut(); }
}

[jonhoo]

Is this a dupe of #16223?

[Mark-Simulacrum]

I don't think so, but am uncertain. Might have the same underlying cause, though -- hard to tell.

[arielb1]

This is as defined by RFC rust-lang/rfcs#130

[jethrogb]

I don't fully understand it, but that RFC sounds like it was intended to make Box more like other types. This issue is pointing out a discrepancy between Box and other types.

e.g., compare the code from the original issue with

fn push(mut node: ::std::cell::RefMut<(i32, i32)>) {
    let (ref mut left, ref mut right) = *node;
}

(compiles)

This sounds to me like Box is still getting special treatment and the RFC has not been fully implemented yet, therefore this issue should remain open.

[arielb1]

@jethrogb

So the RFC was just poorly-defined. I think the solution to mutating in match should be able to be extended to handle this.