Rust借用检查器E0521：trait实现引发借用数据逃逸问题

我正在实现二叉树，希望将节点数据与树的算法分离，使算法具备通用性且独立于数据存储方式。但遇到了借用检查器的异常问题：当为dyn Tree<TValue>实现Display trait时，触发了error[E0521]: borrowed data escapes outside of associated function错误；而改为为TreeNode<TValue>实现Display时，问题就会消失。我无法理解为何trait会引发该问题，相关代码及编译器错误信息如下：

use std::fmt::{Display, Formatter};

struct TreeNode<TValue> {
    value: TValue,
    left: Option<Box<TreeNode<TValue>>>,
    right: Option<Box<TreeNode<TValue>>>,
}

trait Tree<TValue> {
    fn value(&self) -> &TValue;
    fn left(&self) -> Option<&dyn Tree<TValue>>;
    fn right(&self) -> Option<&dyn Tree<TValue>>;
}

impl<TValue> Display for dyn Tree<TValue>
where
    TValue: Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str("(")?;
        Display::fmt(self.value(), f)?;
        f.write_str(", ")?;

        match self.left() {
            Some(ref x) => x.fmt(f)?,
            None => f.write_str("None")?,
        }

        f.write_str(", ")?;

        match self.right().as_ref() {
            Some(x) => x.fmt(f)?,
            None => f.write_str("None")?,
        }

        f.write_str(")")
    }
}

impl<TValue> Tree<TValue> for TreeNode<TValue>
where
    TValue: Display,
{
    fn value(&self) -> &TValue {
        &self.value
    }

    fn left(&self) -> Option<&dyn Tree<TValue>> {
        self.left.as_ref().map(|x| &**x as &dyn Tree<TValue>)
    }

    fn right(&self) -> Option<&dyn Tree<TValue>> {
        self.right.as_ref().map(|x| &**x as &dyn Tree<TValue>)
    }
}

fn main() {
    let tree = Box::new(TreeNode {
        value: 1,
        left: Some(Box::new(TreeNode {
            value: 2,
            left: None,
            right: None,
        })),
        right: Some(Box::new(TreeNode {
            value: 3,
            left: None,
            right: None,
        })),
    }) as Box<dyn Tree<i32>>;

    println!("{}", tree);
}

编译器错误信息：

error[E0521]: borrowed data escapes outside of associated function
  --> src\main.rs:24:15
   |
19 |     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
   |            -----
   |            |
   |            `self` declared here, outside of the associated function body
   |            `self` is a reference that is only valid in the associated function body
   |            let's call the lifetime of this reference `'1`
...
24 |         match self.left() {
   |               ^^^^^^^^^^^
   |               |
   |               `self` escapes the associated function body here
   |               argument requires that `'1` must outlive `'static`

我并未在函数体中捕获值并超出其作用域使用，这是否是借用检查器的限制？

原因分析与解决方案 #

核心原因 #

这个错误源于**Tree trait中的left和right方法缺少显式生命周期标注**。对于动态分发的dyn Tree<TValue>，编译器无法自动推导返回引用与self的生命周期绑定关系，默认会认为返回的&dyn Tree<TValue>需要拥有'static生命周期。而fmt方法中的self是一个短生命周期的引用，无法满足'static的要求，因此触发逃逸错误。

而针对具体类型TreeNode<TValue>实现Display时，编译器可以直接推导出引用的生命周期关系，所以不会报错。

解决步骤 #

1. 为Tree trait添加生命周期标注

明确方法返回的引用与self的生命周期一致，消除编译器的歧义：

trait Tree<TValue> {
    fn value(&self) -> &TValue;
    // 显式标注返回引用与self同生命周期
    fn left<'a>(&'a self) -> Option<&'a dyn Tree<TValue>>;
    fn right<'a>(&'a self) -> Option<&'a dyn Tree<TValue>>;
}

2. 简化Display实现中的匹配逻辑

left()和right()返回的是Option<&dyn Tree<TValue>>，直接解构即可，无需额外的ref或as_ref()：

impl<TValue> Display for dyn Tree<TValue>
where
    TValue: Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str("(")?;
        Display::fmt(self.value(), f)?;
        f.write_str(", ")?;

        match self.left() {
            Some(x) => x.fmt(f)?,
            None => f.write_str("None")?,
        }

        f.write_str(", ")?;

        match self.right() {
            Some(x) => x.fmt(f)?,
            None => f.write_str("None")?,
        }

        f.write_str(")")
    }
}

3. 同步调整TreeNode的trait实现

保持生命周期标注与trait定义一致：

impl<TValue> Tree<TValue> for TreeNode<TValue>
where
    TValue: Display,
{
    fn value(&self) -> &TValue {
        &self.value
    }

    fn left<'a>(&'a self) -> Option<&'a dyn Tree<TValue>> {
        self.left.as_ref().map(|x| &**x as &dyn Tree<TValue>)
    }

    fn right<'a>(&'a self) -> Option<&'a dyn Tree<TValue>> {
        self.right.as_ref().map(|x| &**x as &dyn Tree<TValue>)
    }
}

修改后的完整代码 #

use std::fmt::{Display, Formatter};

struct TreeNode<TValue> {
    value: TValue,
    left: Option<Box<TreeNode<TValue>>>,
    right: Option<Box<TreeNode<TValue>>>,
}

trait Tree<TValue> {
    fn value(&self) -> &TValue;
    fn left<'a>(&'a self) -> Option<&'a dyn Tree<TValue>>;
    fn right<'a>(&'a self) -> Option<&'a dyn Tree<TValue>>;
}

impl<TValue> Display for dyn Tree<TValue>
where
    TValue: Display,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str("(")?;
        Display::fmt(self.value(), f)?;
        f.write_str(", ")?;

        match self.left() {
            Some(x) => x.fmt(f)?,
            None => f.write_str("None")?,
        }

        f.write_str(", ")?;

        match self.right() {
            Some(x) => x.fmt(f)?,
            None => f.write_str("None")?,
        }

        f.write_str(")")
    }
}

impl<TValue> Tree<TValue> for TreeNode<TValue>
where
    TValue: Display,
{
    fn value(&self) -> &TValue {
        &self.value
    }

    fn left<'a>(&'a self) -> Option<&'a dyn Tree<TValue>> {
        self.left.as_ref().map(|x| &**x as &dyn Tree<TValue>)
    }

    fn right<'a>(&'a self) -> Option<&'a dyn Tree<TValue>> {
        self.right.as_ref().map(|x| &**x as &dyn Tree<TValue>)
    }
}

fn main() {
    let tree = Box::new(TreeNode {
        value: 1,
        left: Some(Box::new(TreeNode {
            value: 2,
            left: None,
            right: None,
        })),
        right: Some(Box::new(TreeNode {
            value: 3,
            left: None,
            right: None,
        })),
    }) as Box<dyn Tree<i32>>;

    println!("{}", tree);
}

为什么这样能解决问题？ #

显式标注生命周期后，编译器明确知道left和right返回的引用依赖于self的生命周期，不会再强制要求'static约束。动态分发的dyn Trait必须明确生命周期关系，否则编译器无法保证引用的有效性，从而抛出逃逸错误。

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