rust - 无法分配给结构字段，因为它已被借用，但借用的字段在单独的范围内

Question

我遇到借用检查器问题。我有一个可变变量。我在其上调用了一个接受 &self 的函数。后来我尝试修改该可变变量的一个字段，但借用检查器抗议:“无法分配给 w.field1 因为它被借用了”。

错误消息帮助文档建议将对函数的调用移动到一个单独的范围，但这没有用。

我包含了一个简化的测试场景，其中包含一些可能起作用的其他结构元素。

struct BaseShape<'s> {
   parent: Option<*mut Group<'s>>,
}

struct Circle<'s> {
    shape: BaseShape<'s>,
    radius: f64,
}

struct Group<'s> {
    shape: BaseShape<'s>,
    children: Vec<ShapeWrapper<'s>>,
}

enum ShapeWrapper<'s> {
    Circle(Circle<'s>),
}

struct DataObject<'r, 's> {
    data: &'r ShapeWrapper<'s>,
    computation: bool,
}

impl<'r, 's: 'r> ShapeWrapper<'s> {
    fn inner_compute(&'s self) -> DataObject<'r, 's> {
        DataObject {
            data: &self,
            computation: true,
        }
    } 
}

struct World<'s> {
    items: Vec<ShapeWrapper<'s>>,
    field1: bool,
}

impl<'r, 's: 'r> World<'s> {
    fn compute(&'s self) -> DataObject<'r, 's> {
        let item = self.items.first().unwrap();
        item.inner_compute()
    }
}

pub fn run_main() {
    let item = ShapeWrapper::Circle(Circle {
        shape: BaseShape {
            parent: Option::None,
        },
        radius: 1.0,
    });
    let mut w = World {
        items: vec![item],
        field1: false,
    };

    // ****** separate scope
    {
        let r = w.compute();
        assert_eq!(r.computation, true);
    }

    // ****** why is referenced element still held on here?
    w.field1 = true;
}

我得到的错误是:

error[E0506]: cannot assign to `w.field1` because it is borrowed
  --> src/lifetimes_multiple.rs:60:5
   |
57 |         let r = w.compute();
   |                 ----------- borrow of `w.field1` occurs here
...
60 |     w.field1 = true;
   |     ^^^^^^^^^^^^^^^
   |     |
   |     assignment to borrowed `w.field1` occurs here
   |     borrow later used here

Answer 1

多亏了 Francis Gagné、Chayim Friedman 和 John Kugelman 的有益建议，问题是我对生命周期的描述有点过于明确了。解决方案是只保留长生命周期的生命周期签名，并保持任何其他生命周期引用匿名/隐式，从而允许编译器为较短生命周期的引用推断出适当的生命周期。这是更改后的代码的一部分:

struct DataObject<'r, 's> {
    data: &'r ShapeWrapper<'s>,
    computation: bool,
}

impl<'s> ShapeWrapper<'s> {
    fn inner_compute(&self) -> DataObject<'_, 's> {
        DataObject {
            data: self,
            computation: true,
        }
    } 
}

struct World<'s> {
    items: Vec<ShapeWrapper<'s>>,
    field1: bool,
}

impl<'s> World<'s> {
    fn compute(&self) -> DataObject<'_, 's> {
        let item = self.items.first().unwrap();
        item.inner_compute()
    } 
}