Rust中Trait函数的生命周期设置问题排查

问题背景 #

定义了Atom trait，包含关联类型OP（自有数据版本）和P<'a>（借用视图版本），实现了to_pow_view函数和相等判断方法，遇到两类编译问题：

• 编译器要求在OwnedAtom的eq方法和OwnedPow的test方法中添加'a: 'b生命周期约束，无法理解原因；
• test方法中出现不可变与可变借用冲突，预期不可变借用在eq执行后释放，但实际报错。

相关代码 #

use std::cmp::Eq;

trait Atom {
    type OP: Atom;
    type P<'a>: Atom where Self: 'a;

    fn to_pow_view<'a>(&'a self) -> Self::P<'a>;
}

#[derive(Debug, Clone)]
struct OwnedAtom {
    data: Vec<u8>,
}

impl Atom for OwnedAtom {
    type OP = OwnedAtom;
    type P<'a> = BorrowedAtom<'a>;

    fn to_pow_view<'a>(&'a self) -> Self::P<'a> {
        BorrowedAtom { data: &self.data }
    }
}

impl<'a, 'b> Eq for OwnedAtom where BorrowedAtom<'a>: Eq {
    // 原代码此处缺少合理约束，编译报错
}

impl<'a, 'b> PartialEq<BorrowedAtom<'b>> for OwnedAtom {
    fn eq(&self, other: &BorrowedAtom<'b>) -> bool {
        self.data == other.data
    }
}

#[derive(Debug)]
struct BorrowedAtom<'a> {
    data: &'a Vec<u8>,
}

impl<'a> Atom for BorrowedAtom<'a> {
    type OP = OwnedAtom;
    type P<'b> = BorrowedAtom<'b> where 'a: 'b;

    fn to_pow_view<'b>(&'b self) -> Self::P<'b> {
        BorrowedAtom { data: self.data }
    }
}

impl<'a, 'b> PartialEq<BorrowedAtom<'b>> for BorrowedAtom<'a> {
    fn eq(&self, other: &BorrowedAtom<'b>) -> bool {
        self.data == other.data
    }
}

impl<'a> Eq for BorrowedAtom<'a> {}

struct OwnedPow<A: Atom> {
    atom: A,
}

impl<A: Atom> OwnedPow<A> {
    fn test<'a, 'b>(&'a mut self) -> bool
    where
        A::P<'a>: PartialEq<A::P<'b>>,
        // 原代码此处缺少'a: 'b约束，编译报错
    {
        let view = self.atom.to_pow_view();
        let eq = view.eq(&view);
        self.atom = A::OP::default(); // 可变借用此处报错
        eq
    }
}

impl Default for OwnedAtom {
    fn default() -> Self {
        OwnedAtom { data: Vec::new() }
    }
}

fn main() {
    let mut pow = OwnedPow { atom: OwnedAtom::default() };
    pow.test();
}

核心错误信息 #

1. 生命周期约束错误：

error[E0276]: impl has stricter requirements than trait
  --> src/main.rs:22:1
   |
22 | impl<'a, 'b> Eq for OwnedAtom where BorrowedAtom<'a>: Eq {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: trait `Eq` has no requirements
   = note: but the impl requires `BorrowedAtom<'a>: Eq`

error[E0309]: the parameter type `A::P<'b>` may not live long enough
  --> src/main.rs:54:9
   |
54 |         let eq = view.eq(&view);
   |         ^^^^^^
   |
   = help: consider adding an explicit lifetime bound `A::P<'b>: 'a`...

2. 借用冲突错误：

error[E0502]: cannot borrow `self.atom` as mutable because it is also borrowed as immutable
  --> src/main.rs:55:9
   |
53 |         let view = self.atom.to_pow_view();
   |                    ---------- immutable borrow occurs here
54 |         let eq = view.eq(&view);
   |                  ------- immutable borrow later used here
55 |         self.atom = A::OP::default();
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here

问题1：为什么需要'a: 'b生命周期约束？ #

原因解析 #

Rust编译器需要确保所有引用不会出现悬垂，当涉及跨生命周期的借用视图比较时，必须明确生命周期的包含关系：

• 在BorrowedAtom的Atom实现中，type P<'b> = BorrowedAtom<'b> where 'a: 'b：这里的'a: 'b表示原借用'a的生命周期必须长于新生成的视图借用'b，保证视图引用的底层数据不会提前被销毁。
• 在OwnedPow::test方法中，view是绑定到self生命周期'a的A::P<'a>，而eq方法接收的参数是&A::P<'b>。如果没有'a: 'b约束，编译器无法保证A::P<'a>中的引用能覆盖'b的生命周期，存在悬垂引用风险，因此必须显式声明'a的生命周期不短于'b。

另外，OwnedAtom的Eq实现写法错误：Eq trait不需要额外生命周期参数，直接为OwnedAtom派生或实现Eq即可，因为PartialEq已经满足自反性要求，无需绑定BorrowedAtom的生命周期。

问题2：为什么会出现借用冲突？ #

原因解析 #

Rust的借用检查器会保守地跟踪借用的作用域：

1. let view = self.atom.to_pow_view(); 对self.atom发起不可变借用，view持有该借用的引用；
2. let eq = view.eq(&view); 编译器会认为view的借用生命周期延续到eq变量的整个作用域（即使eq只是布尔值，编译器默认假设view的借用可能被间接持有）；
3. 执行self.atom = A::OP::default();时需要可变借用，此时不可变借用的生命周期未结束，触发冲突。

解决方法 #

通过代码块缩短不可变借用的作用域，让view在代码块结束后立即释放借用：

fn test<'a>(&'a mut self) -> bool
where
    A::P<'a>: PartialEq,
{
    let eq = {
        let view = self.atom.to_pow_view();
        view.eq(&view)
    }; // view在此处销毁，不可变借用释放
    self.atom = A::OP::default();
    eq
}

修正后的完整代码 #

use std::cmp::Eq;

trait Atom {
    type OP: Atom;
    type P<'a>: Atom where Self: 'a;

    fn to_pow_view<'a>(&'a self) -> Self::P<'a>;
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct OwnedAtom {
    data: Vec<u8>,
}

impl Atom for OwnedAtom {
    type OP = OwnedAtom;
    type P<'a> = BorrowedAtom<'a>;

    fn to_pow_view<'a>(&'a self) -> Self::P<'a> {
        BorrowedAtom { data: &self.data }
    }
}

impl<'b> PartialEq<BorrowedAtom<'b>> for OwnedAtom {
    fn eq(&self, other: &BorrowedAtom<'b>) -> bool {
        self.data == other.data
    }
}

#[derive(Debug, PartialEq, Eq)]
struct BorrowedAtom<'a> {
    data: &'a Vec<u8>,
}

impl<'a> Atom for BorrowedAtom<'a> {
    type OP = OwnedAtom;
    type P<'b> = BorrowedAtom<'b> where 'a: 'b;

    fn to_pow_view<'b>(&'b self) -> Self::P<'b> {
        BorrowedAtom { data: self.data }
    }
}

impl<'a, 'b> PartialEq<BorrowedAtom<'b>> for BorrowedAtom<'a> {
    fn eq(&self, other: &BorrowedAtom<'b>) -> bool {
        self.data == other.data
    }
}

struct OwnedPow<A: Atom> {
    atom: A,
}

impl<A: Atom> OwnedPow<A>
where
    A::OP: Default,
{
    fn test<'a>(&'a mut self) -> bool
    where
        A::P<'a>: PartialEq,
    {
        let eq = {
            let view = self.atom.to_pow_view();
            view.eq(&view)
        };
        self.atom = A::OP::default();
        eq
    }
}

impl Default for OwnedAtom {
    fn default() -> Self {
        OwnedAtom { data: Vec::new() }
    }
}

fn main() {
    let mut pow = OwnedPow { atom: OwnedAtom::default() };
    pow.test();
}

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