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

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

当您在 compute() 中使用 &'s self 时，您告诉编译器“只要 's，我就可以保留 self 借用”。 's定义于World，推导为w的整个生命周期。所以，你借 w 度过它的余生。但是你正在尝试使用它（可变地借用它）！您有一个对相同类型的相同对象的可变引用和共享引用（就借用检查器而言）。

见。

Answer 2

感谢 Francis Gagné、Chayim Friedman 和 John Kugelman 的有益建议，问题是我对生命周期的描述有点过于直白了。解决方案是只保留 long-lived 的生命周期签名，并保留任何其他生命周期引用 anonymous/implicit，从而允许编译器为较短生命周期的引用推断出适当的生命周期。这是更改后的代码的一部分：

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

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

Cannot assign to struct field because it is already borrowed, yet borrowed field is in separate scope

rust

borrow-checker