Rust跨模块下Foo、Bar、Baz结构体生命周期错误求助

我想创建一个Foo结构体，它拥有Bar和Baz两个子结构体的所有权，同时让Baz能访问Bar。把三个结构体拆分到foo.rs、bar.rs、baz.rs三个模块时，生命周期处理出现编译错误；但把所有代码放在同一个文件里就能正常运行，甚至不需要给Foo指定匿名生命周期，完全搞不懂这种差异的原因。

模块拆分后的代码 #

foo.rs #

use crate::bar::Bar;
use crate::baz::Baz;

pub struct Foo<'a> {
    bar: Bar,
    baz: Baz<'a>,
}

impl Foo<'_> {
    pub fn new() -> Self {
        let mut s = Self {
            bar: Bar::default(),
            baz: Baz::default(),
        };
        s.baz.bar = Some(&s.bar);
        s
    }
}

bar.rs #

#[derive(Default)]
pub struct Bar {
    value: i32,
}

baz.rs #

use crate::bar::Bar;

#[derive(Default)]
pub struct Baz<'a> {
    value: i32,
    pub bar: Option<&'a Bar>,
}

编译错误信息 #

拆分模块后会触发以下错误：

error[E0597]: `s.bar` does not live long enough
  --> src/foo.rs:13:29
   |
13 |         s.baz.bar = Some(&s.bar);
   |                             ^^^^ 被借用的值生命周期不足
14 |         s
   |         - 返回该值要求 `s.bar` 必须被借用至生命周期 `'a`
15 |     }
   |     - `s.bar` 在此处被销毁，但仍处于借用状态

问题原因分析 #

同一文件能编译通过，是因为Rust的非 lexical 生命周期（NLL） 允许编译器进行更精准的上下文推断：它能识别出&s.bar的引用和Foo实例本身的生命周期是绑定的，暂时允许这种自引用写法。

但跨模块时，编译器的推断会变得保守——模块边界会切断上下文信息，编译器在处理foo.rs的impl代码时，只能看到Baz的公开接口（即Baz<'a>带有一个引用字段），无法确认这个引用的生命周期和Foo内部bar字段的生命周期完全一致，因此会抛出生命周期不匹配的错误。

另外需要注意：即使同一文件能编译，这种直接的自引用结构体也是不安全的——如果Foo实例被移动，Baz里的引用会立即变成悬垂引用，触发未定义行为。

解决方案：避免自引用 #

正确的做法是调整结构，用所有权共享替代直接引用，彻底规避自引用问题。这里推荐用Arc实现共享所有权：

修改后的baz.rs #

use crate::bar::Bar;
use std::sync::Arc;

#[derive(Default)]
pub struct Baz {
    value: i32,
    pub bar: Option<Arc<Bar>>,
}

修改后的foo.rs #

use crate::bar::Bar;
use crate::baz::Baz;
use std::sync::Arc;

pub struct Foo {
    bar: Arc<Bar>,
    baz: Baz,
}

impl Foo {
    pub fn new() -> Self {
        let bar = Arc::new(Bar::default());
        let baz = Baz {
            bar: Some(bar.clone()),
            ..Baz::default()
        };
        Self { bar, baz }
    }
}

这种写法完全不需要生命周期标注，不管是否拆分模块都能正常编译，而且是内存安全的——Arc会自动管理引用计数，确保Bar在被Foo和Baz同时引用时不会被销毁。

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