Rust循环内复用缓冲区返回借用数据时E0499错误解决方法

• 存在一个表示TCP流的结构体，用于接收protobuf编码的消息，其read_event方法负责将原始消息读入缓冲区、解码后返回解码结果。使用quick-protobuf库做解码时，为了减少内存拷贝和分配，解码后的结构体直接持有缓冲区原始数据的引用。
• 另有一个带循环的函数：循环内反复调用read_event，检查返回消息是否满足特定条件，满足则返回该消息退出函数，不满足则丢弃消息进入下一轮循环。
• 核心问题是函数返回匹配消息时会触发借用检查器报错，最小可复现代码如下：

struct Event<'a> {
    u8ref: &'a u8
}

struct EventStream {
    buf: Vec<u8>,
}

impl EventStream {
    fn read_event<'a>(&'a mut self) -> Event<'a> {
        todo!()
    }
}

struct Processor {
    stream: EventStream,
}

impl Processor {
    fn find_it<'a>(&'a mut self) -> Event<'a> {
        loop {
            match self.stream.read_event() {
                event if *event.u8ref == 0x80 => return event,
                _ => {}
            }
        }
    }
}

fn main() {}

error[E0499]: cannot borrow `self.stream` as mutable more than once at a time
  --> src/main.rs:22:19
   |
20 |     fn find_it<'a>(&'a mut self) -> Event<'a> {
   |                -- lifetime `'a` defined here
21 |         loop {
22 |             match self.stream.read_event() {
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ `self.stream` was mutably borrowed here in the previous iteration of the loop
23 |                 event if *event.u8ref == 0x80 => return event,
   |                                                         ----- returning this value requires that `self.stream` is borrowed for `'a`

For more information about this error, try `rustc --explain E0499`.

• 将EventStream从Processor中拆分，作为独立参数传入函数
• 将缓冲区作为独立参数传入函数

报错的核心是稳定版借用检查器的保守判断逻辑无法识别循环内的分支生命周期差异：
read_event返回的Event持有EventStream的可变借用，生命周期和self的生命周期'a绑定。如果某一次迭代拿到的Event不满足条件被丢弃，理论上这次的可变借用就应该被释放，下一次迭代可以重新获取可变借用；但因为函数签名声明返回的Event生命周期为'a（覆盖整个函数调用周期），借用检查器会默认每一次调用read_event产生的借用都要持续到函数返回，因此第二次循环调用时就会触发“重复可变借用”的错误。

方案1：使用Polonius（实验性借用检查器） #

Rust官方开发的新一代借用检查器Polonius可以基于控制流正确识别这种“不返回的分支中借用提前结束”的场景。在Nightly版本下添加#![feature(nll)]配置，配合-Zpolonius参数编译即可直接通过检查，但Polonius目前还未正式稳定，不建议生产环境使用。

方案2：拆分缓冲区所有权，避免循环内长周期借用流 #

将存储消息的缓冲区从EventStream中拆分出来，由上层持有，read_event只需要在调用时临时可变借用流和缓冲区写入数据，返回的Event仅绑定缓冲区的生命周期即可。这样循环中不会对EventStream产生长周期的可变借用，只有缓冲区被返回的Event持有借用，完全符合借用规则。
改造示例代码：

struct Event<'a> {
    u8ref: &'a u8
}

struct EventStream;

impl EventStream {
    // 流的借用为临时生命周期，返回的Event仅绑定缓冲区的生命周期
    fn read_event<'a>(&mut self, buf: &'a mut Vec<u8>) -> Event<'a> {
        todo!()
    }
}

struct Processor {
    stream: EventStream,
    buf: Vec<u8>,
}

impl Processor {
    fn find_it<'a>(&'a mut self) -> Event<'a> {
        loop {
            // self.stream的可变借用在read_event返回后立即释放
            // 返回的event仅绑定self.buf的生命周期'a
            let event = self.stream.read_event(&mut self.buf);
            if *event.u8ref == 0x80 {
                return event;
            }
        }
    }
}

fn main() {}

方案3：匹配到目标消息时做一次拷贝 #

如果结构拆分成本过高，可以在匹配到符合条件的消息时，将消息中引用的数据拷贝为自有数据，解除返回值和缓冲区的生命周期绑定。这种方式下循环中每次调用read_event产生的借用会在当次循环结束后自动释放，不会触发重复借用错误，仅在返回时产生一次内存拷贝，适合目标消息体积不大的场景。

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