Rust报错cannot infer an appropriate lifetime for borrow expression如何解决

你的代码触发生命周期冲突的核心是构造了自引用结构体：Cli 实例同时持有带所有权的 Config 字段，和引用同实例内部 Config 字段的 execution_list 向量，这不符合 Rust 基础生命周期约束：

1. impl<'a> Cli<'a> 中定义的生命周期 'a 约束了 execution_list 内所有引用的存活时长，按照生命周期标注规则，'a 的存活范围必须覆盖整个 Cli 实例的生命周期
2. prepare 方法的 &mut self 参数没有显式标注生命周期，编译器会默认分配独立的匿名生命周期，该生命周期仅绑定当前方法调用的借用周期，远短于 'a。你从 &self.config 中取出的引用最长只能和这个匿名生命周期保持一致，自然无法满足存入 execution_list 要求的 'a 约束
3. 该检查本质是安全拦截：如果允许这种自引用存在，后续一旦修改、移动或删除 Cli 中的 config 字段，execution_list 内的所有引用都会变成悬垂指针，触发未定义行为

方案1：拆分结构体（最推荐，无unsafe、无额外性能开销） #

将Config从Cli结构体中剥离，在使用侧先初始化Config，再将其引用传入Cli的对应方法，从根源避免自引用：

pub struct A<'a> {
    pub a: &'a str,
    pub b: &'a u8,
}
pub enum Executable<'a> {
    ExecutableA(A<'a>),
}
pub struct Config {
    pub a: String,
    pub b: u8,
}
impl Config {
    pub fn new() -> Self {
        unimplemented!()
    }
}
// 移除Cli中的Config所有权字段
pub struct Cli<'a> {
    pub execution_list: Vec<Executable<'a>>,
}
impl<'a> Cli<'a> {
    pub fn new() -> Self {
        Self { execution_list: vec![] }
    }
    // 显式绑定传入的config生命周期和'a一致
    pub fn prepare(&mut self, config: &'a Config) {
        self.execution_list.push(
            Executable::ExecutableA(A {
                a: &config.a,
                b: &config.b,
            })
        )
    }
}

// 调用示例
fn main() {
    let config = Config::new();
    let mut cli = Cli::new();
    cli.prepare(&config);
    // 后续执行逻辑
}

方案2：延迟配置引用到执行阶段（最简洁，无生命周期参数） #

如果Executable仅在执行时需要读取配置，可以去掉Executable的生命周期参数，执行时再传入配置引用，完全规避提前存储引用的生命周期问题：

// 移除所有生命周期参数
pub enum Executable {
    ExecutableA,
}
impl Executable {
    // 执行时再传入配置引用
    pub fn execute(&self, config: &Config) {
        let a = &config.a;
        let b = &config.b;
        // 执行具体逻辑
    }
}
pub struct Cli {
    pub config: Config,
    pub execution_list: Vec<Executable>,
}
impl Cli {
    pub fn new() -> Self {
        Self {
            config: Config::new(),
            execution_list: vec![]
        }
    }
    pub fn prepare(&mut self) {
        self.execution_list.push(Executable::ExecutableA);
    }
    pub fn run(&self) {
        for exe in &self.execution_list {
            exe.execute(&self.config);
        }
    }
}

方案3：使用共享智能指针（适合多场景持有Config的需求） #

如果确实需要多处持有Config的访问权限，可以用Rc（单线程）或Arc（多线程）包裹Config，通过引用计数管理生命周期，无需手动标注生命周期：

use std::rc::Rc;
pub struct A {
    config: Rc<Config>,
}
impl A {
    pub fn a(&self) -> &str {
        &self.config.a
    }
    pub fn b(&self) -> &u8 {
        &self.config.b
    }
}
pub enum Executable {
    ExecutableA(A),
}
pub struct Cli {
    pub config: Rc<Config>,
    pub execution_list: Vec<Executable>,
}
impl Cli {
    pub fn new() -> Self {
        Self {
            config: Rc::new(Config::new()),
            execution_list: vec![]
        }
    }
    pub fn prepare(&mut self) {
        self.execution_list.push(
            Executable::ExecutableA(A {
                // Rc的clone仅增加引用计数，无深拷贝性能开销
                config: self.config.clone()
            })
        );
    }
}

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