Rust中trait可变与不可变引用的可选可变性实现方案探讨

你提到的问题在处理大型AST时确实很常见——维护Visitor（只读）和Folder（修改）两套trait会产生大量重复代码，增加维护成本。以下是几种更优的实现思路，无需冗余代码即可支持可选可变性：

1. 用泛型参数统一可变性控制 #

通过将引用类型抽象为泛型参数，让同一个trait同时支持不可变引用和可变引用，避免重复定义trait结构。

mod ast {
    pub struct Name { pub value: String }
    pub struct Stmt { /* ... */ }
    pub struct Expr { /* ... */ }
}

mod generic_visit {
    use super::ast::*;

    // 通用Visitor trait，用N泛型表示节点的引用类型（&Name 或 &mut Name）
    pub trait Visitor<T, N> {
        fn visit_name(&mut self, n: N) -> T;
        fn visit_stmt(&mut self, s: N) -> T;
        fn visit_expr(&mut self, e: N) -> T;
    }

    // 为只读场景实现泛型Visitor
    impl<T, V> Visitor<T, &Name> for V
    where
        V: super::visit::Visitor<T>,
    {
        fn visit_name(&mut self, n: &Name) -> T {
            super::visit::Visitor::visit_name(self, n)
        }

        fn visit_stmt(&mut self, s: &Stmt) -> T {
            super::visit::Visitor::visit_stmt(self, s)
        }

        fn visit_expr(&mut self, e: &Expr) -> T {
            super::visit::Visitor::visit_expr(self, e)
        }
    }

    // 为可变修改场景实现泛型Visitor
    struct MutVisitor;
    impl<T> Visitor<T, &mut Name> for MutVisitor {
        fn visit_name(&mut self, n: &mut Name) -> T {
            // 直接修改节点
            n.value = "modified".to_string();
            unimplemented!()
        }

        fn visit_stmt(&mut self, s: &mut Stmt) -> T { unimplemented!() }
        fn visit_expr(&mut self, e: &mut Expr) -> T { unimplemented!() }
    }
}

// 原有的只读Visitor trait可以作为泛型实现的基础
mod visit {
    use super::ast::*;

    pub trait Visitor<T> {
        fn visit_name(&mut self, n: &Name) -> T;
        fn visit_stmt(&mut self, s: &Stmt) -> T;
        fn visit_expr(&mut self, e: &Expr) -> T;
    }
}

这种方案通过泛型参数切换引用类型，复用一套trait结构，编译时就能保证借用规则的正确性。

2. 内部可变性实现无侵入修改 #

如果只是需要在遍历过程中修改AST节点的局部数据，不想改动现有Visitor的结构，可以用Rust的内部可变性（比如RefCell）包装节点的可变字段。

use std::cell::RefCell;

mod ast {
    use super::RefCell;
    pub struct Name {
        // 用RefCell包装可变字段
        pub value: RefCell<String>,
    }
    pub struct Stmt { /* 同理包装可变字段 */ }
    pub struct Expr { /* 同理包装可变字段 */ }
}

mod visit {
    use super::ast::*;

    // 保持原有只读Visitor的结构
    pub trait Visitor<T> {
        fn visit_name(&mut self, n: &Name) -> T {
            // 无需可变引用，直接修改内部数据
            *n.value.borrow_mut() = "updated_name".to_string();
            unimplemented!()
        }

        fn visit_stmt(&mut self, s: &Stmt) -> T { unimplemented!() }
        fn visit_expr(&mut self, e: &Expr) -> T { unimplemented!() }
    }
}

注意：内部可变性会把借用检查从编译时移到运行时，要确保不会出现同时多次可变借用的情况（否则会panic），适合单线程、借用逻辑明确的场景。

3. 宏自动生成可变/不可变实现 #

当AST节点数量较多时，用Rust宏自动生成两套trait的实现，彻底消除重复代码。

mod ast {
    pub struct Name { pub value: String }
    pub struct Stmt;
    pub struct Expr;
}

// 定义宏自动生成Visitor和MutVisitor
macro_rules! generate_visitor_traits {
    ($($node:ident),*) => {
        pub trait Visitor<T> {
            $(
                fn visit_$node(&mut self, node: &$node) -> T;
            )*
        }

        pub trait MutVisitor<T> {
            $(
                fn visit_$node(&mut self, node: &mut $node) -> T;
            )*
        }

        // 为MutVisitor提供默认实现，直接调用Visitor的方法（适用于无需修改节点的场景）
        $(
            impl<V, T> MutVisitor<T> for V
            where
                V: Visitor<T>,
            {
                fn visit_$node(&mut self, node: &mut $node) -> T {
                    self.visit_$node(node)
                }
            }
        )*
    };
}

mod visit {
    use super::ast::*;
    // 传入所有AST节点类型，自动生成两套trait
    generate_visitor_traits!(Name, Stmt, Expr);

    // 只读Visitor实现
    struct ReadOnlyPrinter;
    impl Visitor<()> for ReadOnlyPrinter {
        fn visit_name(&mut self, node: &Name) {
            println!("Name: {}", node.value);
        }

        fn visit_stmt(&mut self, _: &Stmt) {}
        fn visit_expr(&mut self, _: &Expr) {}
    }

    // 可变修改Visitor实现
    struct NodeUpdater;
    impl MutVisitor<()> for NodeUpdater {
        fn visit_name(&mut self, node: &mut Name) {
            node.value = "new_value".to_string();
        }

        // 其他方法可以沿用默认实现（调用只读Visitor的逻辑）
    }
}

宏可以一次性生成所有节点的访问方法，后续新增AST节点时只需修改宏的参数即可，大幅降低维护成本。

4. 统一采用“返回新节点”的Folder模式 #

如果你愿意遵循Rust的不可变优先原则，可以统一用Folder模式，只读场景下直接返回原节点即可，无需维护两套trait。

mod ast {
    pub struct Name { pub value: String }
    pub struct Stmt;
    pub struct Expr;
}

mod fold {
    use super::ast::*;

    pub trait Folder {
        // 为所有方法提供默认实现：直接返回原节点
        fn fold_name(&mut self, n: Box<Name>) -> Box<Name> { n }
        fn fold_stmt(&mut self, s: Box<Stmt>) -> Box<Stmt> { s }
        fn fold_expr(&mut self, e: Box<Expr>) -> Box<Expr> { e }
    }

    // 只读遍历实现：只重写需要处理的方法
    struct ReadOnlyVisitor;
    impl Folder for ReadOnlyVisitor {
        fn fold_name(&mut self, n: Box<Name>) -> Box<Name> {
            println!("Visiting name: {}", n.value);
            // 返回原节点，无修改
            n
        }
    }

    // 修改节点实现：重写需要修改的方法
    struct NodeModifier;
    impl Folder for NodeModifier {
        fn fold_name(&mut self, mut n: Box<Name>) -> Box<Name> {
            n.value = "modified".to_string();
            n
        }
    }
}

这种方案的优势是代码统一，所有遍历逻辑都基于同一个Folder trait，只读和修改场景只是实现不同而已，不需要额外维护一套Visitor。

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