Rust 在检查已借用的字段时，如何创建对其自身引用计数的值？

我正在尝试创建一个可变结构

B

，它存储其他结构

a

的实例，这些结构包含对

B

的引用。我想要一个实现，使得对原始

B

进行的任何变异都会传播到

A

s中保存的引用

然而，在变异过程中，我必须检查包装在

a

实例中的

B

实例中的字段，从而打破了“一个可变异或多个不变”规则。我需要不可变地借用，而可变地借用，但是不可变的借用是变异函数内部的，并且不会超出其范围

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct A {
    t: Weak<RefCell<B>>,
}

#[derive(Debug)]
struct B {
    a: usize,
    item: Option<A>,
}

impl B {
    pub fn mutate(&mut self, item: A) {
        {
            let t = item.t.upgrade().unwrap();

            // This check has to be done.
            //
            assert![t.borrow().a == self.a, "not equal"];
            //      ~~~~~~~~~~ panics on this borrow
        }
        //
        // The immutable borrow should end here.

        self.item = Some(item);
        self.a += 1;
    }
}

fn main() {
    let b = B { item: None, a: 0 };

    let bc = Rc::new(RefCell::new(b));

    let f = A {
        t: Rc::downgrade(&bc),
    };

    bc.borrow_mut().mutate(f);

    println!["{:?}", bc.borrow().item.as_ref().unwrap().t.upgrade()];
}

仅使用

Rc

可以满足这些要求吗？如果不是，我是否必须陷入

不安全的
代码？
文档中，比如：

恐慌
如果当前价值是可变借来的，则恐慌。为了不惊慌
变体，使用

使用
try_borrow
时，要知道任何现有的借用必须是
自身的
（因此是相等的），这样您的代码就可以编译：

let eq = t.try_borrow().map_or(true, |v| v.a == self.a);
assert![eq, "not equal"];

另见：



这看起来很有希望。然而，
try\u forrow
即使在
t
的其他字段被可变借用时也会失败，对吗？因此，如果我使用这种方法，我必须仔细观察语义。不过，非常感谢。