Rust借用检查器问题：提前返回仍触发多重可变引用错误

问题代码 #

原函数实现：

fn bst_impl<'a>(graph: &Graph, max_k: &u16, vc: &'a mut HashSet<u16>) -> Option<&'a HashSet<u16>> {

    if vc.len() > *max_k as usize {
        return None;
    }

    let mut edge: Option<(u16, u16)> = None;

    'outer: for (u, edges) in graph.adj_list.iter().enumerate() {
        if vc.contains(&(u as u16)) {
            continue;
        }
        for v in edges {
            if !vc.contains(&(*v as u16)) {
                edge = Some((u as u16, *v));
                break 'outer;
            }
        }
    }

    match edge {
        None => {
            return Some(vc);
        }
        Some((u, v)) => {

            vc.insert(u);
            if let Some(result) = bst_impl(graph, max_k, vc) {
                return Some(result);
            } else {
                vc.insert(v);
                if let Some(result) = bst_impl(graph, max_k, vc) {
                    return Some(result);
                }
            }

            return None;
        }
    }
}

核心逻辑片段：

vc.insert(u);
if let Some(result) = bst_impl(graph, max_k, vc) {
    return Some(result);
} else {
    vc.insert(v);
    if let Some(result) = bst_impl(graph, max_k, vc) {
        return Some(result);
    }
}

编译错误 #

error[E0499]: cannot borrow `*vc` as mutable more than once at a time
  --> src/bst.rs:43:17
   |
13 | fn bst_impl<'a>(graph: &Graph, max_k: &u16, vc: &'a mut HashSet<u16>) -> Option<&'a HashSet<u16>> {
   |             -- lifetime `'a` defined here
...
40 |             if let Some(result) = bst_impl(graph, max_k, vc) {
   |                                                          -- first mutable borrow occurs here
41 |                 return Some(result);
   |                        ------------ returning this value requires that `*vc` is borrowed for `'a`
42 |             } else {
43 |                 vc.insert(u);
   |                 ^^^^^^^^^^^^ second mutable borrow occurs here

问题原因：当前Rust借用检查器无法智能识别if let分支提前返回后不会进入else分支，它会判定vc的可变借用在整个if-else块中持续存在，导致后续的vc.insert(v)触发二次可变借用冲突。

无克隆重构方案 #

通过将递归调用的结果先存储到临时变量，让编译器明确感知到当结果为None时，之前的可变借用已经结束，从而允许再次借用vc：

vc.insert(u);
// 将递归结果存入临时变量，明确借用范围
let res = bst_impl(graph, max_k, vc);
if res.is_some() {
    return res;
}
// 此时res已离开作用域，vc的可变借用已释放
vc.insert(v);
if let Some(result) = bst_impl(graph, max_k, vc) {
    return Some(result);
}

替换原核心逻辑片段后，完整函数可正常编译，且无需对HashSet进行任何克隆操作。

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