Rust借用检查器报错：局部作用域销毁后仍存在多引用冲突

我正在为解释器实现基于哈希表链表的变量环境栈，以全局作用域为起点，采用RAII管理局部作用域。但局部变量local销毁后操作global时，Rust借用检查器仍报E0502错误（可变与不可变借用冲突）。

我的疑问：

• 为何local已出作用域仍会触发该错误？
• 如何在不使用RefCell（避免性能开销）的前提下修复问题？

相关代码 #

use std::collections::HashMap;

struct Env<'a, T> {
    map: HashMap<String, T>,
    parent: Option<&'a mut Env<'a, T>>
}

impl<'a, T> Env<'a, T> {
    fn new() -> Self {
        Self {map: HashMap::new(), parent: None}
    }

    fn insert(&mut self, key: String, val: T) {
        self.map.insert(key, val);
    }

    fn get(&self, key: &str) -> Option<&T> {
        self.map.get(key).or_else(|| self.parent.as_ref().map(|parent| parent.get(key)).flatten())
    }

    fn get_mut(&mut self, key: &str) -> Option<&mut T> {
        self.map.get_mut(key).or_else(|| self.parent.as_mut().map(|parent| parent.get_mut(key)).flatten())
    }

    fn new_scope(&'a mut self) -> Env<'a, T> {
        Env { map: HashMap::new(), parent: Some(self) }
    }
}

#[test]
fn test() {
    let mut global = Env::new();
    global.insert("x".to_string(), "global x");
    println!("{:?}", global.get("x")); // global x
    println!("{:?}", global.get("y")); // none
    global.get_mut("x").map(|val| *val = "new global x");
    println!("{:?}", global.get("x")); // new global x
    {
        let mut local = global.new_scope();
        println!("{:?}", local.get("x")); // new global x
        local.get_mut("x").map(|val| *val = "new new global x");
        println!("{:?}", local.get("x")); // new new global x
        local.insert("x".to_string(), "local x");
        println!("{:?}", local.get("x")); // local x
        local.insert("y".to_string(), "y");
        println!("{:?}", local.get("y")); // y
    }
    // the following lines causes compiler error
    // i don't get it b/c `local` is already out of scope!!
    println!("{:?}", global.get("x")); // global x
    println!("{:?}", global.get("y")); // none
    global.insert("y".to_string(), "global y");
    println!("{:?}", global.get("y")); // global y
}

错误信息 #

error[E0502]: cannot borrow `global` as immutable because it is also borrowed as mutable
  --> src/env2.rs:50:22
   |
39 |         let mut local = global.new_scope();
   |                         ------------------ mutable borrow occurs here
...
50 |     println!("{:?}", global.get("x")); // global x
   |                      ^^^^^^^^^^^^^^^
   |                      |
   |                      immutable borrow occurs here
   |                      mutable borrow later used here

问题解答 #

1. 为何local出作用域后仍报错？ #

核心问题在于生命周期绑定错误：

• Env<'a, T>结构体中，parent持有&'a mut Env<'a, T>类型的引用，这里的'a同时绑定了父作用域的引用生命周期和结构体自身的生命周期。
• new_scope函数签名fn new_scope(&'a mut self) -> Env<'a, T>，将self的可变借用生命周期直接绑定到结构体的'a参数。而global的生命周期覆盖整个test函数，因此编译器判定这个可变借用的生命周期和global一样长——即使local被销毁，global的可变借用仍被标记为未释放，后续操作自然触发可变/不可变借用冲突。

2. 无RefCell的修复方案 #

调整生命周期设计，让子作用域的借用生命周期独立于父结构体的生命周期，避免永久绑定：

use std::collections::HashMap;

// 用'parent表示父作用域的生命周期，与结构体自身生命周期解耦
struct Env<'parent, T> {
    map: HashMap<String, T>,
    parent: Option<&'parent mut Env<'parent, T>>,
}

impl<T> Env<'_, T> {
    fn new() -> Self {
        Self { map: HashMap::new(), parent: None }
    }

    fn insert(&mut self, key: String, val: T) {
        self.map.insert(key, val);
    }

    fn get(&self, key: &str) -> Option<&T> {
        self.map.get(key).or_else(|| {
            self.parent.as_ref().and_then(|parent| parent.get(key))
        })
    }

    fn get_mut(&mut self, key: &str) -> Option<&mut T> {
        self.map.get_mut(key).or_else(|| {
            self.parent.as_mut().and_then(|parent| parent.get_mut(key))
        })
    }

    // 用独立的生命周期'b，将子作用域的借用生命周期限制在当前代码块内
    fn new_scope<'b>(&'b mut self) -> Env<'b, T> {
        Env { map: HashMap::new(), parent: Some(self) }
    }
}

#[test]
fn test() {
    let mut global = Env::new();
    global.insert("x".to_string(), "global x");
    println!("{:?}", global.get("x")); // global x
    println!("{:?}", global.get("y")); // none
    global.get_mut("x").map(|val| *val = "new global x");
    println!("{:?}", global.get("x")); // new global x
    {
        let mut local = global.new_scope();
        println!("{:?}", local.get("x")); // new global x
        local.get_mut("x").map(|val| *val = "new new global x");
        println!("{:?}", local.get("x")); // new new global x
        local.insert("x".to_string(), "local x");
        println!("{:?}", local.get("x")); // local x
        local.insert("y".to_string(), "y");
        println!("{:?}", local.get("y")); // y
    }
    // 现在这些操作正常执行
    println!("{:?}", global.get("x")); // new new global x
    println!("{:?}", global.get("y")); // none
    global.insert("y".to_string(), "global y");
    println!("{:?}", global.get("y")); // global y
}

修复说明：

• 将结构体的生命周期参数改为'parent，明确表示这是父作用域的引用生命周期，与结构体自身生命周期解耦。
• new_scope函数使用独立的生命周期'b，返回的Env<'b, T>持有对self的'b生命周期可变引用。当local离开代码块时，'b生命周期结束，global的可变借用被自动释放，后续对global的操作不再触发借用冲突。

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