Rust中如何在引用即将失效时移动其作用域内的AST节点？

问题核心 #

你遇到的本质是Rust所有权与借用规则的冲突：当通过引用（&expr）匹配AST节点时，原表达式的所有权仍被持有，此时无法移动引用指向的深层节点——编译器无法确保引用会在移动后立即失效。

解决方案：通过所有权匹配实现安全移动 #

关键是直接匹配表达式的所有权而非引用，让编译器确认没有存活的引用指向待移动的节点。以下是几种符合Rust风格的实现方式：

1. 基础版本：处理单次双重取反 #

直接通过if let解构所有权，避免引用：

enum Expr {
    Int(i64),
    Var(String),
    BinOp(char, Box<Expr>, Box<Expr>),
    UnOp(char, Box<Expr>),
}

fn simplify(expr: Expr) -> Expr {
    // 直接匹配expr的所有权，解构外层取反
    if let Expr::UnOp('-', inner) = expr {
        // 解构内层Box的所有权
        match *inner {
            // 匹配到双重取反，直接移动最内层节点返回
            Expr::UnOp('-', target) => *target,
            // 不是双重取反，重构表达式返回
            inner_expr => Expr::UnOp('-', Box::new(inner_expr)),
        }
    } else {
        // 其他表达式直接返回
        expr
    }
}

2. 递归版本：处理多层嵌套取反+深层简化 #

如果需要递归简化整个AST（比如处理-(-(-(12)))这类多层取反，或先简化内层表达式），可以先递归简化子节点，再处理双重取反：

fn simplify(expr: Expr) -> Expr {
    let simplified = match expr {
        Expr::UnOp(op, inner) => {
            // 先递归简化内层表达式
            let simplified_inner = simplify(*inner);
            if op == '-' {
                // 内层简化后如果是取反，直接移动目标节点
                if let Expr::UnOp('-', target) = simplified_inner {
                    *target
                } else {
                    Expr::UnOp('-', Box::new(simplified_inner))
                }
            } else {
                Expr::UnOp(op, Box::new(simplified_inner))
            }
        }
        Expr::BinOp(op, left, right) => {
            // 递归简化左右子节点
            let left_simplified = simplify(*left);
            let right_simplified = simplify(*right);
            Expr::BinOp(op, Box::new(left_simplified), Box::new(right_simplified))
        }
        // 叶子节点直接返回
        leaf @ (Expr::Int(_) | Expr::Var(_)) => leaf,
    };
    simplified
}

3. 循环版本：迭代处理多层取反 #

如果不想用递归，也可以用循环迭代处理多层取反，避免栈溢出（针对极深的嵌套）：

fn simplify(mut expr: Expr) -> Expr {
    loop {
        expr = match expr {
            Expr::UnOp('-', inner) => match *inner {
                Expr::UnOp('-', target) => *target,
                inner_expr => break Expr::UnOp('-', Box::new(inner_expr)),
            },
            _ => break expr,
        };
    }
    expr
}

关键原理 #

Rust的借用规则禁止在有活跃引用的情况下移动值。当你直接匹配expr（所有权转移）而非&expr（引用）时，匹配分支会获得对应节点的所有权，此时解构内层节点并移动其内容是安全的——编译器能确认没有其他引用指向这些节点。这种方式完全避免了子树复制，符合零成本抽象的Rust设计理念。

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