Rust借用冲突问题：为何大括号无法解决E0502错误？

问题背景 #

我之前多次遇到Rust的借用错误，通常给问题代码套个大括号限制作用域就能解决，但这次碰到了特殊情况。以下是我的代码：

fn breadth_first_index(
    root: CargoCrateVersionNode,
    redis_connection: &mut Connection,
    show_dev_dependencies: bool,
    show_build_dependencies: bool,
) {
    let mut already_included_versions = vec![root.ccv_version_id];
    let mut dependency_tree: Vec<(Option<DependsOnEdge>, CargoCrateVersionNode)> = 
        vec![(None, root)];

    let mut i = 0;
    while i < dependency_tree.len() {
        let (edge_to_current_dependency, current_dependency) = &dependency_tree[i];

        let mut command = 
            format!("match (main:CargoCrateVersion)-[edge:depends_on]->(connected) where main.ccv_version_id = {} and (edge.doe_kind = 0", current_dependency.ccv_version_id);
        if show_dev_dependencies {
            command.push_str(" or edge.doe_kind = 2");
        }
        if show_build_dependencies {
            command.push_str(" or edge.doe_kind = 1");
        }
        command.push_str(" )");
        command.push_str(" return edge, connected");

        let redis_answ = redis_connection.graph_query(GRAPH_NAME, command).unwrap();
        let mut parsed_dependencies = 
            CargoCrateVersionNode::parse_bulk(&redis_answ.data, "connected").unwrap();
        let mut parsed_edges = DependsOnEdge::parse_bulk(&redis_answ.data, "edge").unwrap();

        while !parsed_dependencies.is_empty() {
            let dependency = parsed_dependencies.remove(0);
            let edge = parsed_edges.remove(0);

            if already_included_versions.contains(&dependency.ccv_version_id) {
                continue;
            }
            // 这里的if let触发了错误
            // 我试过给这段代码套大括号，但没用
            if let Some(edge_to_current) = &edge_to_current_dependency {
                if edge_to_current.doe_optional {
                    if let Some(edge_features) = &edge_to_current.doe_with_features {
                        println!("{:?}", edge_features);
                    }
                }
            }

            already_included_versions.push(dependency.ccv_version_id);
            dependency_tree.push((Some(edge), dependency));
        }
        i += 1;
    }
    println!("---- Dependency tree ----");
    for l in dependency_tree {
        println!("{:?}", l.1);
    }
}

使用rustc 1.63（Rust 2021 edition）编译时，收到如下错误：

226 |         let (edge_to_current_dependency, current_dependency) = &dependency_tree[i];
    |                                                                 --------------- 不可变借用在此处发生...
253 |                 if let Some(edge_to_current) = edge_to_current_dependency {
    |                                                -------------------------- 不可变借用在此处被后续使用
...
262 |             dependency_tree.push((Some(edge), dependency));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 可变借用在此处发生

For more information about this error, try `rustc --explain E0502`.
error: could not compile `package_finder` due to previous error

我知道问题出在：先获取了可变列表元素的不可变引用，之后又对列表做了可变借用。但我给if let块套大括号后还是报错，怀疑是不是编译器的Bug？

后来我用直接访问数组的方式解决了问题，但这种写法不太理想：

if let Some(edge_to_current) = &dependency_tree[i].0 {}

错误原因分析 #

这不是编译器Bug，而是借用检查器的正常行为。问题核心在于edge_to_current_dependency变量的生命周期：

• 它是从&dependency_tree[i]解构出来的引用，变量的作用域是整个while循环的当前迭代块（从let (...) = &dependency_tree[i];到i += 1;的所有代码）。
• 哪怕给if let代码套了大括号，edge_to_current_dependency本身仍处于外部作用域，它持有的不可变借用会持续到当前迭代结束。
• 而dependency_tree.push()是对整个Vec的可变借用，和之前的不可变借用在时间上重叠，因此触发E0502错误。

你后来用&dependency_tree[i].0的方式能生效，是因为每次访问都会创建一个临时引用，这个引用的生命周期仅局限于if let语句本身，执行完if let后引用就被释放，不会和后续的push操作冲突。

更优雅的解决方案 #

除了直接访问数组的方式，还有两种更清晰的写法：

1. 提前复制所需数据，彻底避免持有引用 #

如果current_dependency.ccv_version_id是可Copy/Clone的类型，或者edge_to_current_dependency的内容可以克隆，可以提前把需要的数据从列表中取出，不再持有列表元素的引用：

while i < dependency_tree.len() {
    // 提前取出需要的数据，解除对dependency_tree的引用依赖
    let ccv_version_id = dependency_tree[i].1.ccv_version_id;
    let edge_ref = dependency_tree[i].0.as_ref();

    let mut command = 
        format!("match (main:CargoCrateVersion)-[edge:depends_on]->(connected) where main.ccv_version_id = {} and (edge.doe_kind = 0", ccv_version_id);
    // 后续command构建逻辑不变

    // 解析redis响应的代码不变

    while !parsed_dependencies.is_empty() {
        // 前面的代码不变

        if already_included_versions.contains(&dependency.ccv_version_id) {
            continue;
        }

        // 使用提前取出的edge_ref
        if let Some(edge_to_current) = edge_ref {
            if edge_to_current.doe_optional {
                if let Some(edge_features) = &edge_to_current.doe_with_features {
                    println!("{:?}", edge_features);
                }
            }
        }

        // 此时已无dependency_tree的引用，push操作不会触发冲突
        already_included_versions.push(dependency.ccv_version_id);
        dependency_tree.push((Some(edge), dependency));
    }
    i += 1;
}

2. 拆分引用使用与列表修改的代码块 #

如果不需要提前复制数据，可以把使用引用的代码和修改列表的代码彻底拆分，确保引用在修改列表前就被释放：

while !parsed_dependencies.is_empty() {
    let dependency = parsed_dependencies.remove(0);
    let edge = parsed_edges.remove(0);

    if already_included_versions.contains(&dependency.ccv_version_id) {
        continue;
    }

    // 单独块内使用引用，执行完后引用立即失效
    {
        if let Some(edge_to_current) = edge_to_current_dependency {
            if edge_to_current.doe_optional {
                if let Some(edge_features) = &edge_to_current.doe_with_features {
                    println!("{:?}", edge_features);
                }
            }
        }
    }

    // 此时引用已释放，可安全修改列表
    already_included_versions.push(dependency.ccv_version_id);
    dependency_tree.push((Some(edge), dependency));
}

总结 #

这不是编译器的Bug，而是你之前的做法没有真正限制住引用的生命周期——edge_to_current_dependency的作用域覆盖了dependency_tree.push()操作，导致不可变借用与可变借用重叠。通过提前复制数据或拆分代码块，就能优雅解决这个问题。

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