Rust E0506错误：借用值赋值——无关表达式的借用冲突

问题重现 #

尝试用Option和Box实现无unsafe的基础单向链表，编写删除should_remove为true的节点方法时，触发E0506错误。简化代码如下：

struct Node {
    should_remove: bool,
    next_node: Option<Box<Node>>,
}

struct SinglyLinkedList {
    head: Option<Box<Node>>,
}

impl SinglyLinkedList {
    fn remove_certain_nodes(&mut self) {
        let mut current_node_link = &mut self.head;
        while let Some(current_node /* &mut Box<Node> */) = current_node_link {
            if current_node.should_remove {
                let next_node_link = current_node.next_node.take();
                std::mem::drop(current_node);
                *current_node_link = next_node_link;
            }
            else {
                current_node_link = &mut current_node.next_node;
            }
        }
    }
}

编译报错：

error[E0506]: cannot assign to `*current_node_link` because it is borrowed
  --> src/main.rs:18:17
   |
13 |         while let Some(current_node /* &mut Box<Node> */) = current_node_link {
   |                        ------------ `*current_node_link` is borrowed here
...
18 |                 *current_node_link = next_node_link;
   |                 ^^^^^^^^^^^^^^^^^^
   |                 |
   |                 `*current_node_link` is assigned to here but it was already borrowed
   |                 borrow later used here

手动drop(current_node)也无法解决该冲突，而Nightly版本的Polonius借用检查器可以正常编译。

冲突原因 #

当前稳定版Rust的借用检查器在while let模式匹配时，会将current_node（&mut Box<Node>类型）的借用生命周期绑定到整个循环体。即使手动drop了current_node，借用检查器依然认为原变量*current_node_link的借用尚未释放——因为它无法精确追踪到current_node在循环体内部的实际使用范围，仅根据语法结构判定借用覆盖了整个循环块。此时对*current_node_link的赋值操作，会被判定为“在借用期间修改原可变引用”，从而触发E0506错误。

Polonius作为下一代借用检查器，采用了更精确的数据流分析，能识别出current_node在drop后已不再被使用，因此允许后续的赋值操作，但目前仅在Nightly版本中可用。

优化重构方案 #

方案1：通过take()手动管理所有权（推荐） #

利用Option::take()主动解除current_node_link的可变绑定，手动控制节点的所有权转移，彻底规避借用生命周期重叠的问题：

impl SinglyLinkedList {
    fn remove_certain_nodes(&mut self) {
        let mut current_link = &mut self.head;
        while let Some(mut node) = current_link.take() {
            if node.should_remove {
                // 将当前节点的后继节点赋值给current_link，完成删除
                *current_link = node.next_node.take();
            } else {
                // 将当前节点放回链表，再移动current_link到后继节点
                *current_link = Some(node);
                current_link = &mut current_link.as_mut().unwrap().next_node;
            }
        }
    }
}

方案2：用match替代while let拆分逻辑 #

通过loop+match的结构，让借用检查器能识别每个分支的借用范围独立，避免生命周期绑定到整个循环体：

impl SinglyLinkedList {
    fn remove_certain_nodes(&mut self) {
        let mut current_link = &mut self.head;
        loop {
            match current_link {
                Some(node) if node.should_remove => {
                    let next = node.next_node.take();
                    *current_link = next;
                }
                Some(node) => {
                    current_link = &mut node.next_node;
                }
                None => break,
            }
        }
    }
}

这两种方案都不需要依赖Nightly特性，能在稳定版Rust中正常编译，且逻辑清晰、符合Rust的所有权规则。

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