为何实现Drop的包装类型在循环中可变借用会触发编译错误？

问题重现 #

最小示例代码 #

struct Wrapper<'a>(&'a mut i32);
impl<'a> Drop for Wrapper<'a> {
    fn drop(&mut self) {}
}
fn main() {
    let mut a = 0;
    let mut f = None;
    for _ in 0..100 {
        f = match f {
            None => Some(Wrapper(&mut a)),
            Some(a) => Some(a),
        };
    }
}

编译错误 #

error[E0499]: cannot borrow `a` as mutable more than once at a time
  --> src/main.rs:10:34
   |
9  |         f = match f {
   |                   - first borrow used here, in later iteration of loop
10 |             None => Some(Wrapper(&mut a)),
   |                                  ^^^^^^ `a` was mutably borrowed here in the previous iteration of the loop

现象与实际场景 #

移除Wrapper的Drop实现后代码可正常编译。在嵌入式no_std场景中，类似业务类型如下：

struct FileFormatReader<'a> {
    file: SomeFileHandleWithCloseOnDrop, // 实现Drop以自动关闭文件
    internal_buffer: &'a mut u8,         // 外部静态分配的缓冲区，无内存分配
}

需要动态替换FileFormatReader实例（无文件状态、更新当前文件内容、切换到新文件复用同一缓冲区），目前临时方案是Option<ManuallyDrop<FileFormatReader>>，但手动管理drop容易出错。

这是编译器Bug吗？ #

不是。

Rust的借用检查器对实现了Drop trait的类型会做更严格的生命周期分析：当类型实现Drop时，编译器无法确定drop方法是否会访问持有的引用（即使你的drop是空实现）。为了保证内存安全，编译器会假设drop可能随时访问引用，因此会延长借用的生命周期，避免在旧引用可能被使用时创建新的可变借用。

而未实现Drop的类型，编译器通过**非 lexical lifetimes（NLL）**优化，可以明确旧的引用在赋值后不再被使用，因此允许重新借用。

Semver风险说明 #

给类型新增Drop trait确实属于破坏性变更，会导致依赖代码可能编译失败，符合语义化版本控制中需要升级大版本（major version）的场景。库作者在给已有类型添加Drop时必须谨慎，需在版本更新中明确标注这一不兼容变更。

解决方案 #

方案1：使用Option::take()明确生命周期边界 #

通过take()将旧实例从Option中移出，让编译器明确旧引用的生命周期结束时机，避免借用冲突：

struct Wrapper<'a>(&'a mut i32);
impl<'a> Drop for Wrapper<'a> {
    fn drop(&mut self) {}
}
fn main() {
    let mut a = 0;
    let mut f = None;
    for _ in 0..100 {
        // 先取出旧实例，打破原有的借用链
        let current = f.take();
        f = match current {
            None => Some(Wrapper(&mut a)),
            Some(w) => Some(w), // 将旧实例放回，无需重新借用
        };
    }
}

该方案无需unsafe代码，完全符合安全Rust规范，适配你的嵌入式场景：

// 适配FileFormatReader的示例
fn main() {
    let mut buffer: [u8; 1024] = [0; 1024];
    let mut reader: Option<FileFormatReader> = None;
    
    for _ in 0..100 {
        let current = reader.take();
        reader = match current {
            None => Some(FileFormatReader {
                file: SomeFileHandleWithCloseOnDrop::open("file1.bin"),
                internal_buffer: &mut buffer,
            }),
            Some(mut r) => {
                // 模拟更新当前文件状态
                r.read_more();
                Some(r)
            }
        };
    }
}

方案2：封装安全的手动drop逻辑（针对ManuallyDrop优化） #

如果必须使用ManuallyDrop，可以封装辅助函数减少手动操作的出错概率：

use std::mem::ManuallyDrop;

struct FileFormatReader<'a> {
    file: SomeFileHandleWithCloseOnDrop,
    internal_buffer: &'a mut u8,
}

impl<'a> FileFormatReader<'a> {
    /// 安全替换旧实例：先drop旧实例，再返回新实例
    pub fn replace(old: Option<ManuallyDrop<Self>>, new: Option<Self>) -> Option<ManuallyDrop<Self>> {
        // 手动drop旧实例，确保引用被释放
        if let Some(old) = old {
            unsafe { ManuallyDrop::drop(&old); }
        }
        new.map(ManuallyDrop::new)
    }
}

// 使用示例
fn main() {
    let mut buffer: [u8; 1024] = [0; 1024];
    let mut reader: Option<ManuallyDrop<FileFormatReader>> = None;
    
    for _ in 0..100 {
        reader = FileFormatReader::replace(reader, match reader {
            None => Some(FileFormatReader {
                file: SomeFileHandleWithCloseOnDrop::open("file1.bin"),
                internal_buffer: &mut buffer,
            }),
            Some(_) => {
                // 保留旧实例，先转成非ManuallyDrop再放回
                reader.take().map(|m| unsafe { ManuallyDrop::into_inner(m) })
            }
        });
    }
}

注意：该方案涉及unsafe代码，需确保drop操作不会导致悬垂引用。

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