调用Bump的reset方法后为何无法使用其引用？

我在测试Bumpalo内存池（arena），原本以为这段代码会编译通过但运行时出错，没想到编译器直接捕获了问题。但我不确定编译器的推理是否正确，求解释。

测试代码 #

use bumpalo::Bump;

fn main() {
    let mut bump = Bump::new();
    let b1: &mut Bob = bump.alloc(Bob::default());
    let b2: &mut Bob = bump.alloc(Bob::default());
    let b3: &mut Bob = bump.alloc(Bob::new(Some(b1), Some(b2)));
    println!("{:?}", b2);
    {
        bump.reset();
    }
    println!("{:?}", b2);
}

#[derive(Debug)]
struct Bob {
    son: Option<*mut Bob>,
    parent: Option<*mut Bob>,
    string: String,
}
impl Bob {
    fn new(son: Option<*mut Bob>, parent: Option<*mut Bob>) -> Bob {
        Bob {
            son,
            parent,
            ..Bob::default()
        }
    }
}

impl Default for Bob {
    fn default() -> Bob {
        Bob {
            son: None,
            parent: None,
            string: String::from("Hello"),
        }
    }
}

编译器错误信息 #

error[E0502]: 无法可变借用`bump`，因为它已被不可变借用
  --> src\main.rs:10:9
   |
6  |     let b2: &mut Bob = bump.alloc(Bob::default());
   |                        -------------------------- 不可变借用在此处发生
...
10 |         bump.reset();
   |         ^^^^^^^^^^^^ 可变借用在此处发生
11 |     }
12 |     println!("{:?}", b2);
   |                      -- 不可变借用在此处被后续使用

Bumpalo相关核心代码 #

alloc方法 #

pub fn alloc<T>(&self, val: T) -> &mut T {
    self.alloc_with(|| val)
}

alloc_with方法 #

#[inline(always)]
#[allow(clippy::mut_from_ref)]
pub fn alloc_with<F, T>(&self, f: F) -> &mut T
where
    F: FnOnce() -> T,
{
    #[inline(always)]
    unsafe fn inner_writer<T, F>(ptr: *mut T, f: F)
    where
        F: FnOnce() -> T,
    {
        // 该函数的执行逻辑为：
        // - 在栈上为T分配空间
        // - 调用f()，将返回值存入栈空间
        // - 将栈上数据拷贝到堆上
        //
        // 理想情况下，我们希望LLVM总能意识到栈分配是不必要的，
        // 并优化代码使其直接写入堆中。将关键代码单独抽成函数，
        // 似乎能更稳定地让LLVM实现这一优化，而非内联到周边代码中。
        ptr::write(ptr, f())
    }

    let layout = Layout::new::<T>();

    unsafe {
        let p = self.alloc_layout(layout);
        let p = p.as_ptr() as *mut T;
        inner_writer(p, f);
        &mut *p
    }
}

reset方法 #

pub fn reset(&mut self) {
    // 接收`&mut self`，因此`self`必须是唯一的，且不能存在任何会因重置而失效的活跃借用。
    unsafe {
        if self.current_chunk_footer.get().as_ref().is_empty() {
            return;
        }

        let mut cur_chunk = self.current_chunk_footer.get();

        // 释放除当前块外的所有块
        let prev_chunk = cur_chunk.as_ref().prev.replace(EMPTY_CHUNK.get());
        dealloc_chunk_list(prev_chunk);

        // 将指针重置到块的起始位置
        cur_chunk.as_ref().ptr.set(cur_chunk.cast());

        // 重置块的已分配字节数
        cur_chunk.as_mut().allocated_bytes = cur_chunk.as_ref().layout.size();

        debug_assert!(
            self.current_chunk_footer
                .get()
                .as_ref()
                .prev
                .get()
                .as_ref()
                .is_empty(),
            "我们应仅保留一个块"
        );
        debug_assert_eq!(
            self.current_chunk_footer.get().as_ref().ptr.get(),
            self.current_chunk_footer.get().cast(),
            "块的指针应重置到其分配的起始位置"
        );
    }
}

问题解释 #

编译器的报错完全正确，核心逻辑围绕Rust的借用规则和Bumpalo的内存模型展开：

1. 借用规则的强制约束 #

Rust的核心借用规则明确：同一时间，一个值不能同时存在活跃的可变借用和不可变/可变借用。

• bump.alloc接收&self（不可变借用），但通过unsafe代码返回了&mut T——这是Bumpalo为适配内存池模型做的特殊处理，但编译器仍会追踪返回引用的生命周期。
• b2作为alloc返回的&mut Bob，它的生命周期与bump的不可变借用绑定，直到b2最后一次被使用（即最后一行的println），这个不可变借用始终处于活跃状态。

2. reset的安全要求 #

bump.reset()需要&mut self（可变借用），目的是确保调用时内存池处于独占状态——因为reset会重置分配指针、释放部分内存块，此时如果存在任何指向内存池的活跃引用，这些引用会立即变成悬垂引用，后续访问会引发未定义行为。

编译器通过借用检查提前阻止了这种危险：它发现b2的活跃借用还未结束，就尝试对bump进行可变借用，直接触发E0502错误。

3. alloc方法的unsafe合理性 #

alloc从&self生成&mut T的unsafe操作是安全的，因为Bumpalo保证：

• 分配的内存块在reset或内存池销毁前不会被回收
• 同一内存块不会被重复分配给其他引用
  但这种安全的前提是用户遵守规则——不能在存在活跃引用时调用reset，而编译器的借用检查正好强制了这一点，避免用户违反内存安全约定。

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