Rust错误E0506排查：无法赋值给self.inner因已被借用

问题描述 #

我想实现一个函数，当内部数据的id变化时更新数据，然后返回该数据的引用，但遇到了借用检查器错误，不清楚原因。以下是简化示例代码及报错信息：

struct SomeData {
    id: i32,
    other_data: (),
}

impl SomeData {
    fn new(id: i32) -> Self {
        Self {
            id,
            other_data: (),
        }
    }
}

struct MyData {
    inner: Option<SomeData>,
}

impl MyData {
    fn update(&mut self, id: i32) -> &SomeData {
        match  self.inner.as_ref() {
            Some(inner) if inner.id == id => {
                return inner
            }
            _ => {}
        }
        // 这里原本认为inner的引用已经被释放
        
        self.inner = Some(SomeData::new(id));
        
        // 报错：`self.inner` is assigned to here but it was already borrowed
        self.inner.as_ref().unwrap()
    }
}

报错信息 #

error[E0506]: cannot assign to `self.inner` because it is borrowed
  --> src/lib.rs:30:9
   |
20 |     fn update(&mut self, id: i32) -> &SomeData {
   |               - let's call the lifetime of this reference `'1`
21 |         match  self.inner.as_ref() {
   |                ---------- `self.inner` is borrowed here
22 |             Some(inner) if inner.id == id => {
23 |                 return inner
   |                        ----- returning this value requires that `self.inner` is borrowed for `'1`
...
30 |         self.inner = Some(SomeData::new(id));
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `self.inner` is assigned to here but it was already borrowed

For more information about this error, try `rustc --explain E0506`.

原因解释 #

Rust的借用检查器在这里无法精准识别引用的存活范围：当你在match的分支里返回inner时，这个引用的生命周期被强制绑定到函数返回的&SomeData的生命周期（也就是self的可变引用生命周期'1）。借用检查器会认为，只要存在一个分支返回了这个引用，那么self.inner的借用会持续到整个函数结束——哪怕后续分支里根本没有使用这个引用，也无法对self.inner进行赋值操作。

修复方案 #

我们可以通过拆分判断逻辑，先获取当前id的拷贝（不持有self.inner的长期借用），再进行比较，让借用检查器能正确识别借用的结束时机：

struct SomeData {
    id: i32,
    other_data: (),
}

impl SomeData {
    fn new(id: i32) -> Self {
        Self {
            id,
            other_data: (),
        }
    }
}

struct MyData {
    inner: Option<SomeData>,
}

impl MyData {
    fn update(&mut self, id: i32) -> &SomeData {
        // 先获取当前内部数据的id（仅临时借用，用完即释放）
        let current_id = self.inner.as_ref().map(|data| data.id);
        
        // 比较id，若匹配直接返回引用
        if current_id == Some(id) {
            return self.inner.as_ref().unwrap();
        }
        
        // id不匹配时更新数据，此时self.inner没有被借用
        self.inner = Some(SomeData::new(id));
        self.inner.as_ref().unwrap()
    }
}

另一种更简洁的写法是用if let分开判断，同样能让借用检查器正确识别借用范围：

impl MyData {
    fn update(&mut self, id: i32) -> &SomeData {
        if let Some(inner) = &self.inner {
            if inner.id == id {
                return inner;
            }
        }
        
        self.inner = Some(SomeData::new(id));
        self.inner.as_ref().unwrap()
    }
}

这两种写法都能让借用检查器明白：在执行赋值操作的代码路径中，self.inner的借用已经完全释放，因此可以安全地修改它。

内容的提问来源于stack exchange，提问作者Defernus