为何Accessor方法会引发生命周期错误（与内联实现对比）

问题说明 #

• version1()无法编译通过，但逻辑完全等价的version2()可以正常工作，两者仅有的区别是version1()使用了get_x_mut访问器方法，而version2()直接内联了该方法的实现逻辑
• 实际开发中需要用访问器方法来抽象嵌套字段的访问逻辑，但当前写法触发了借用检查错误
• 疑惑点：明明没有存储任何引用，却出现了跨循环迭代的借用冲突

代码示例 #

struct Bar<'a> {
    foo: Option<&'a Foo<'a>>
}

impl<'a> Bar<'a> {
    fn bar(&mut self) {}
}

struct Foo<'a> {
    x: Bar<'a>,
    y: Option<Bar<'a>>
}

impl<'a> Foo<'a> {
    fn get_x_mut(&'a mut self) -> &'a mut Bar {
        &mut self.x
    }
    
    fn get_y(&self) -> &Option<Bar> {
        &self.y
    }

    fn version1(&'a mut self) {
        loop {
            if let Some(y) = self.get_y() {
                let x = self.get_x_mut();
                x.bar();
            }
        }
    }
    
    fn version2(&'a mut self) {
        loop {
            if let Some(y) = self.get_y() {
                let x = &mut self.x;
                x.bar();
            }
        }
    }
}

错误信息 #

error[E0502]: cannot borrow `*self` as immutable because it is also borrowed as mutable
  --> src/lib.rs:25:30
   |
14 | impl<'a> Foo<'a> {
   |      -- lifetime `'a` defined here
...
25 |             if let Some(y) = self.get_y() {
   |                              ^^^^^^^^^^^^ immutable borrow occurs here
26 |                 let x = self.get_x_mut();
   |                         ----------------
   |                         |
   |                         mutable borrow occurs here
   |                         argument requires that `*self` is borrowed for `'a`

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/lib.rs:26:25
   |
14 | impl<'a> Foo<'a> {
   |      -- lifetime `'a` defined here
...
26 |                 let x = self.get_x_mut();
   |                         ^^^^^^^^^^^^^^^^
   |                         |
   |                         `*self` was mutably borrowed here in the previous iteration of the loop
   |                         argument requires that `*self` is borrowed for `'a`

问题根源 #

1. 访问器方法的生命周期强制绑定 #

get_x_mut的方法签名fn get_x_mut(&'a mut self) -> &'a mut Bar把self的可变借用生命周期强制绑定到了结构体Foo的生命周期'a。这意味着调用get_x_mut后，self的可变借用会持续到整个结构体的存活周期，而不是仅在当前代码块内有效。

反观version2()里直接写&mut self.x，Rust的借用检查器能自动推断出更短的生命周期：这个可变借用只在x.bar()执行期间有效，执行完毕后就会被释放，不会影响后续循环里的get_y()不可变借用。

2. 跨循环的借用冲突 #

因为get_x_mut把self的可变借用绑定到了'a，第一次循环调用该方法后，self就被“永久”（相对于结构体生命周期）标记为可变借用状态。下一次循环迭代时，调用get_y()需要不可变借用self，就触发了E0502错误；再次调用get_x_mut则触发E0499错误——因为self已经处于可变借用状态且无法释放。

哪怕没有存储引用，方法签名的强制生命周期绑定让借用检查器认定self的借用会一直持续，最终导致跨循环的冲突。

修复方案 #

修改get_x_mut的签名，不要强制绑定到结构体的生命周期'a，让Rust自动推断合适的短生命周期：

fn get_x_mut(&mut self) -> &mut Bar<'a> {
    &mut self.x
}

或者显式标注匿名生命周期（效果和上面一致）：

fn get_x_mut<'b>(&'b mut self) -> &'b mut Bar<'a> {
    &mut self.x
}

修改后，get_x_mut的可变借用生命周期会被限制在方法调用后的代码块内，不会绑定到结构体的整个生命周期'a，此时version1()就能正常编译，和version2()的行为完全一致。

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