为什么 RefCell:borrow_mut 在用于短路布尔 AND (&&) 的两侧时会导致 BorrowMutError？

Question

我为 leetcode same tree problem 编写了这段代码：

use std::cell::RefCell;
use std::rc::Rc;

// Definition for a binary tree node.
#[derive(Debug, PartialEq, Eq)]
pub struct TreeNode {
    pub val: i32,
    pub left: Option<Rc<RefCell<TreeNode>>>,
    pub right: Option<Rc<RefCell<TreeNode>>>,
}

impl TreeNode {
    #[inline]
    pub fn new(val: i32) -> Self {
        TreeNode {
            val,
            left: None,
            right: None,
        }
    }
}

struct Solution;

impl Solution {
    pub fn is_same_tree(
        p: Option<Rc<RefCell<TreeNode>>>,
        q: Option<Rc<RefCell<TreeNode>>>,
    ) -> bool {
        match (p, q) {
            (None, None) => true,
            (Some(p), Some(q)) if p.borrow().val == q.borrow().val => {
                // this line won't work, it will cause BorrowMutError at runtime
                // but the `a & b` version works
                return (Self::is_same_tree(
                    p.borrow_mut().left.take(),
                    q.borrow_mut().left.take(),
                )) && (Self::is_same_tree(
                    p.borrow_mut().right.take(),
                    q.borrow_mut().right.take(),
                ));

                let a = Self::is_same_tree(p.borrow_mut().left.take(), q.borrow_mut().left.take());
                let b =
                    Self::is_same_tree(p.borrow_mut().right.take(), q.borrow_mut().right.take());
                a && b
            }
            _ => false,
        }
    }
}

fn main() {
    let p = Some(Rc::new(RefCell::new(TreeNode {
        val: 1,
        left: Some(Rc::new(RefCell::new(TreeNode::new(2)))),
        right: Some(Rc::new(RefCell::new(TreeNode::new(3)))),
    })));
    let q = Some(Rc::new(RefCell::new(TreeNode {
        val: 1,
        left: Some(Rc::new(RefCell::new(TreeNode::new(2)))),
        right: Some(Rc::new(RefCell::new(TreeNode::new(3)))),
    })));

    println!("{:?}", Solution::is_same_tree(p, q));
}

playground

thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:39:23

我认为&& 是一个短路运算符，这意味着两个表达式不会同时存在，所以两个可变引用不应该同时存在。

Answer 1

一个最小化的例子：

use std::cell::RefCell;

fn main() {
    let x = RefCell::new(true);
    *x.borrow_mut() && *x.borrow_mut();
}

thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:8:27

当您调用RefCell::borrow_mut 时，会返回一个RefMut 类型的临时值。来自the reference：

临时的放置范围通常是封闭语句的结尾。

还有in expanded detail:

除了生命周期延长之外，表达式的临时范围是 包含表达式的最小范围，并且是其中之一 以下：

• 整个函数体。
• 声明。
• if、while 或 loop 表达式的主体。
• if 表达式的 else 块。
• if 或 while 表达式或 match 守卫的条件表达式。
• 匹配臂的表达式。
• lazy boolean expression 的第二个操作数。

如果扩展失败的代码，它将看起来像这样：

{
    let t1 = x.borrow_mut();

    *t1 && {
        let t2 = x.borrow_mut();
        *t2
    }
}

这显示了双借是如何发生的。

正如您已经注意到的，您可以通过提前声明一个变量来解决这个问题。这保留了短路性质：

let a = *x.borrow_mut();
a && *x.borrow_mut();