函数参数中的可变借用

Question

为什么下面的代码不能编译（playground）：

use std::collections::HashMap;

fn main() {
    let mut h: HashMap<u32, u32> = HashMap::new();
    h.insert(0, 0);
    h.insert(1, h.remove(&0).unwrap());
}

借用检查器抱怨：

error[E0499]: cannot borrow `h` as mutable more than once at a time
 --> src/main.rs:6:17
  |
6 |     h.insert(1, h.remove(&0).unwrap());
  |     - ------    ^ second mutable borrow occurs here
  |     | |
  |     | first borrow later used by call
  |     first mutable borrow occurs here

然而，代码是安全的，最后一行的几乎机械转换使其可以编译 (playground)：

    //h.insert(1, h.remove(&0).unwrap());
    let x = h.remove(&0).unwrap();
    h.insert(1, x);

据我了解，此类问题已通过非词汇生命周期得到解决。 This question 就是一个例子，还有很多其他的。

到底有没有一些微妙之处使得第一个变体不正确，所以 Rust 拒绝它是正确的？还是所有情况下 NLL 功能仍未完成？

Answer 1

您的问题也适用于可能更令人惊讶的相关案例 - 当方法参数需要 &mut self 时，方法调用需要 &self：

use std::collections::HashMap;

fn main() {
    let mut h: HashMap<u32, u32> = HashMap::new();
    h.insert(0, 0);
    h.contains_key(&h.remove(&0).unwrap());
}

Rust 借用检查器使用它所谓的两阶段借用。 chat I had with Niko Matsakis 的编辑转录：

两阶段借用的想法是，外部&mut 被视为& 借用，直到它被实际使用，或多或少。这使它与内部& 兼容，因为两个& 混合在一起，但它与内部&mut 不兼容。

如果我们想支持这一点，我们就必须添加一种新的借用方式——即，“未激活”&mut 的行为不像 &，它会像其他东西一样（ &const，也许……“其他人可以变异”）

不太清楚这是否可行，而且它似乎添加了更多概念，因此我们选择不支持它。

正如您所说，这是安全的，因为内部借用在外部借用开始之前完成，但实际上在编译器中意识到此时过于复杂。

另见：

• Nested method calls via two-phase borrowing
• Two-phase borrows in Guide to Rustc Development
• Cannot borrow as immutable because it is also borrowed as mutable in function arguments

Answer 2

Rust 编译器首先评估调用对象，然后是传递给它的参数。这就是为什么它首先借用h.insert，然后是h.remove。由于h 已经可变地借用了insert，因此它拒绝了remove 的第二次借用。

使用下一代借用检查器 Polonius 时，这种情况不会改变。您可以使用 nightly 编译器自己尝试一下：
RUSTFLAGS=-Zpolonius cargo +nightly run

C++ 中的求值顺序类似：https://riptutorial.com/cplusplus/example/19369/evaluation-order-of-function-arguments