Destructuring boxes into multiple mutable references seems broken

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.

#![feature(box_patterns)]

box pattern

There. Now other people can find this bug.

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(); }
}

Is this a dupe of #16223?

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

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

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.

@jethrogb

@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.

3 of these 4 cases fail with Rust 1.25.0. The good news is that with NLL, all 4 work! 🎉

use std::ops::{Deref, DerefMut};

// Fails
fn smart_two_field(v: &mut Wrap<(i32, i32)>) {
    let _a = &mut v.0;
    let _b = &mut v.1;
}

fn smart_destructure(v: &mut Wrap<(i32, i32)>) {
    let (ref mut _head, ref mut _tail) = **v;
}

// Fails
fn box_two_field(v: &mut Box<(i32, i32)>) {
    let _a = &mut v.0;
    let _b = &mut v.1;
}

// Fails
fn box_destructure(v: &mut Box<(i32, i32)>) {
    let (ref mut _head, ref mut _tail) = **v;
}

// My own smart pointer
struct Wrap<T>(T);

impl<T> Deref for Wrap<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.0
    }
}

impl<T> DerefMut for Wrap<T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.0
    }
}

fn main() {}

Add regression test for issue rust-lang#30104

Rollup merge of rust-lang#53349 - memoryruins:nll-tests, r=nikomatsakis

Auto merge of #53449 - frewsxcv:rollup, r=frewsxcv

Auto merge of #59114 - matthewjasper:enable-migate-2015, r=<try>

Auto merge of #59114 - matthewjasper:enable-migate-2015, r=pnkfelix

Navigation Menu

Repository navigation

Destructuring boxes into multiple mutable references seems broken #30104

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Destructuring boxes into multiple mutable references seems broken #30104

Description

Activity

jethrogb commented on Feb 16, 2016

aidanhs commented on Jun 2, 2016

jonhoo commented on Oct 31, 2017

Mark-Simulacrum commented on Oct 31, 2017

arielb1 commented on Oct 31, 2017

jethrogb commented on Oct 31, 2017

arielb1 commented on Nov 1, 2017

shepmaster commented on May 8, 2018

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions