Why is the mutable reference copied?

[pngliu]

Hi,

I learned that shared references can be copied, but mutable references cannot, and gave it a try. But the result is confusing.

Rust rejected t1 as expected, but it accepts t2. Why?

fn main() {
    t1();
    t2();
}

fn t1() {
    let mut a: i32 = 0;
    let r1 = &mut a;

    let r2 = r1;            // error[E0382]: borrow of moved value: `r1`

    println!("{}", r1);
}

fn t2() {
    let mut a: i32 = 0;
    let r1 = &mut a;

    let r2: &mut i32 = r1;  // OK!

    println!("{}", r1);
}

[nerditation]

@pngliu

    let r2: &mut i32 = r1;  // OK!

r2 is a reborrow of r1. you can use r1 again after the last use of r2.

for example, this is OK:

    let mut a: i32 = 0;
    let r1 = &mut a;

    let r2: &mut i32 = r1;

    println!("{}", r2);
    println!("{}", r1);

but this is NOT:

    let mut a: i32 = 0;
    let r1 = &mut a;

    let r2: &mut i32 = r1;

    println!("{}", r1);
    println!("{}", r2);

see also this recent thread:

Simple resources about reborrowing for beginners?

I have collected some basic links to start learning about reborrowing which apparently isn't very well documented, and I haven't found it in the book. (I'm at Ch 9-10) I wonder whether there are some other links you would add, and what does the addition of that information to the book depend upon (or what's blocking it?) ? haibane_tenshi's blog - Obscure Rust: reborrowing is a half-baked feature better documentation of reborrowing · Issue #788 · rust-lang/reference · GitHub this is the ma…

[debrunbaix]

Hello,

So the second is wrong because r2 depend of r1 that is already used ?

[Schard]

let r2 = r1; moves the reference r1 into r2, thus invaliding r1. This happens because exclusive references are intentionally not Copy.

As nerditation already mentioned, adding the type hint causes a reborrow instead of a move, which is equivalent to let r2 = &mut *r1;.

[anon65535354]

@debrunbaix

the second is wrong because r2 depend of r1 that is alrea

It's wrong because they are exclusive. While r2 is active r1 can't be used/read there.

[Schard]

I think there's some confusion here. In the OP there is no double exclusive borrow error. It's a use-after-move error.

[anon65535354]

@nerditation

    let mut a: i32 = 0;
    let r1 = &mut a;

    let r2: &mut i32 = r1;

    println!("{}", r1); // cant use r1 if r2 is used afterwards
    println!("{}", r2);

I'm talking about this (comment is mine), which is what I interpreted @debrunbaix was asking about, which is not the OP.

[Schard]

Yes. This is a multiple mutable borrow error, constructed by nerditation, which has nothing to do with the actual error OP faced in their initial post.