为什么可变引用没有移到这里？

Question

我的印象是可变引用（即&mut T）总是被移动。这是完全合理的，因为它们允许独占的可变访问。 在下面的代码中，我将一个可变引用分配给另一个可变引用，并移动了原始引用。结果我不能再使用原来的了：

let mut value = 900;
let r_original = &mut value;
let r_new = r_original;
*r_original; // error: use of moved value *r_original

如果我有这样的功能：

fn make_move(_: &mut i32) {
}

并将我原来的示例修改为如下所示：

let mut value = 900;
let r_original = &mut value;
make_move(r_original);
*r_original; // no complain

我希望当我用它调用函数make_move 时，可变引用r_original 会被移动。然而，这不会发生。通话后我仍然可以使用参考。

如果我使用泛型函数make_move_gen：

fn make_move_gen<T>(_: T) {
}

然后这样称呼它：

let mut value = 900;
let r_original = &mut value;
make_move_gen(r_original);
*r_original; // error: use of moved value *r_original

引用再次移动，因此程序的行为符合我的预期。 为什么调用make_move函数时引用没有移动？

Code example

Answer 1

这实际上可能有一个很好的理由。

&mut T 实际上不是一种类型：所有借用都由一些（可能无法表达的）生命周期参数化。

当一个人写作时

fn move_try(val: &mut ()) {
    { let new = val; }
    *val
}

fn main() {
    move_try(&mut ());
}

类型推断引擎推断typeof new == typeof val，因此它们共享原始生命周期。这意味着从new 借用不会结束，直到从val 借用才结束。

这意味着它相当于

fn move_try<'a>(val: &'a mut ()) {
    { let new: &'a mut _ = val; }
    *val
}

fn main() {
    move_try(&mut ());
}

但是，当你写的时候

fn move_try(val: &mut ()) {
    { let new: &mut _ = val; }
    *val
}

fn main() {
    move_try(&mut ());
}

发生了强制转换——同样的事情可以让你抛弃指针的可变性。这意味着生命周期是一些（似乎无法指定）'b < 'a。这涉及强制转换，因此涉及重借，因此重借可能会超出范围。

总是重新借用规则可能会更好，但显式声明并没有太大问题。

Answer 2

我问了一些类似here的问题。

似乎在某些（很多？）情况下，不是移动，而是重新借入。没有违反内存安全性，只有“移动”的值仍然存在。我也找不到关于这种行为的任何文档。

@Levans 打开了一个 github 问题 here，尽管我并不完全相信这只是一个文档问题：可靠地移出 &mut 引用似乎是 Rust 所有权方法的核心。

Answer 3

它是implicit reborrow。不是well documented的话题。

这个问题已经很好回答了：

1. how implicit reborrow works
2. how reborrow works along with borrow split

Answer 4

如果我稍微调整一下通用的，它也不会抱怨

fn make_move_gen<T>(_: &mut T) {
}

或

let _ = *r_original;