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

我为 leetcode 编写了这段代码同一棵树问题 https://leetcode.com/problems/same-tree/:

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

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

I think &&是一个短路运算符，这意味着两个表达式不会同时存在，因此两个可变引用不应同时存在。

一个最小化的例子：

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 https://doc.rust-lang.org/std/cell/struct.RefCell.html#method.borrow_mut, 类型的临时值RefMut https://doc.rust-lang.org/std/cell/struct.RefMut.html被返回。从参考资料 https://doc.rust-lang.org/1.47.0/reference/expressions.html#temporaries:

临时的删除范围通常是封闭语句的末尾。

And 详细展开 https://doc.rust-lang.org/1.47.0/reference/destructors.html#temporary-scopes:

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

• 整个函数体。
• 一份声明。
• 一个的身体if, while or loop表达。
• The else块的if表达。
• 的条件表达式if or while表达式，或match guard.
• 火柴臂的表达式。
• a 的第二个操作数惰性布尔表达式 https://doc.rust-lang.org/1.47.0/reference/expressions/operator-expr.html#lazy-boolean-operators.

如果展开的话，失败的代码将如下所示：

{
    let t1 = x.borrow_mut();

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

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

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

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