Rust代码变异与AST操作库mutatis使用指南

mutatis是一个强大的Rust库，用于进行抽象语法树(AST)操作和代码转换，特别适合实现代码重构、静态分析和代码生成等任务。

主要特性

• 提供简洁的API进行AST节点匹配和转换
• 支持精确的源码位置跟踪
• 可保留原始代码格式和注释
• 高性能的AST遍历和修改能力

基本使用方法

首先在Cargo.toml中添加依赖：

[dependencies]
mutatis = "0.3"
syn = "1.0"
quote = "1.0"

示例1：简单的AST遍历

use mutatis::Mutator;
use syn::{parse_quote, ItemFn};

fn main() {
    let mut mutator = Mutator::new();
    let code = r#"
        fn add(a: i32, b: i32) -> i32 {
            a + b
        }
    "#;
    
    mutator.register_mutation(
        |item: &ItemFn| {
            println!("Found function: {}", item.sig.ident);
            None // 返回None表示不修改这个节点
        }
    );
    
    mutator.mutate_string(code).unwrap();
}

示例2：AST节点修改

use mutatis::{Mutator, Mutation};
use syn::{parse_quote, ItemFn, Stmt, Expr};
use quote::quote;

fn main() {
    let mut mutator = Mutator::new();
    let code = r#"
        fn add(a: i32, b: i32) -> i32 {
            a + b
        }
    "#;
    
    // 修改函数体，添加日志语句
    mutator.register_mutation(
        |item: &ItemFn| {
            if item.sig.ident == "add" {
                let new_stmt: Stmt = parse_quote! {
                    println!("Adding {} and {}", a, b);
                };
                
                let mut new_block = item.block.clone();
                new_block.stmts.insert(0, new_stmt);
                
                Some(Mutation::replace(item.block.clone(), new_block))
            } else {
                None
            }
        }
    );
    
    let modified = mutator.mutate_string(code).unwrap();
    println!("{}", modified);
}

示例3：复杂重构 - 重命名函数参数

use mutatis::{Mutator, Mutation};
use syn::{parse_quote, ItemFn, Pat, Ident};
use quote::quote;

fn main() {
    let mut mutator = Mutator::new();
    let code = r#"
        fn calculate(x: f64, y: f64) -> f64 {
            x * x + y * y
        }
    "#;
    
    // 重命名函数参数
    mutator.register_mutation(
        |item: &ItemFn| {
            if item.sig.ident == "calculate" {
                let mut new_fn = item.clone();
                
                // 修改参数名
                for input in new_fn.sig.inputs.iter_mut() {
                    if let syn::FnArg::Typed(pat_type) = input {
                        if let Pat::Ident(pat_ident) = &*pat_type.pat {
                            let new_name = match pat_ident.ident.to_string().as_str() {
                                "x" => Ident::new("base", pat_ident.ident.span()),
                                "y" => Ident::new("exponent", pat_ident.ident.span()),
                                _ => continue,
                            };
                            pat_type.pat = Box::new(parse_quote!(#new_name));
                        }
                    }
                }
                
                Some(Mutation::replace(item.clone(), new_fn))
            } else {
                None
            }
        }
    );
    
    let modified = mutator.mutate_string(code).unwrap();
    println!("{}", modified);
}

高级用法：自定义访问者模式

对于更复杂的AST操作，可以实现自定义访问者：

use mutatis::{Mutator, Visitor, Mutation};
use syn::{visit::Visit, ItemFn, ExprBinary};

struct AddToMultiplyVisitor;

impl<'ast] Visit<'ast> for AddToMultiplyVisitor {
    fn visit_expr_binary(&mut self, node: &'ast ExprBinary) {
        if let syn::BinOp::Add(_) = node.op {
            // 找到加法表达式
            println!("Found addition at {:?}", node);
        }
    }
}

fn main() {
    let code = r#"
        fn calc(a: i32, b: i32) -> i32 {
            a + b
        }
    "#;
    
    let mut visitor = AddToMultiplyVisitor;
    let syntax = syn::parse_file(code).unwrap();
    visitor.visit_file(&syntax);
    
    // 可以进一步结合Mutator实现转换
}

完整示例：将加法转换为乘法

下面是一个完整的示例，展示如何使用mutatis将代码中的所有加法运算转换为乘法运算：

use mutatis::{Mutator, Mutation};
use syn::{parse_quote, Expr, ExprBinary, BinOp};
use quote::quote;

fn main() {
    let mut mutator = Mutator::new();
    let code = r#"
        fn calculate(a: i32, b: i32) -> i32 {
            let c = a + b;
            let d = c + 5;
            a + d
        }
    "#;
    
    // 注册变异规则：将+替换为*
    mutator.register_mutation(
        |expr: &ExprBinary| {
            if let BinOp::Add(_) = expr.op {
                let left = &expr.left;
                let right = &expr.right;
                // 创建新的乘法表达式
                let new_expr: Expr = parse_quote! {
                    #left * #right
                };
                Some(Mutation::replace(expr.clone(), new_expr))
            } else {
                None
            }
        }
    );
    
    let modified = mutator.mutate_string(code).unwrap();
    println!("Modified code:\n{}", modified);
    
    /* 输出结果：
    fn calculate(a: i32, b: i32) -> i32 {
        let c = a * b;
        let d = c * 5;
        a * d
    }
    */
}

最佳实践

1. 精确匹配：在修改AST前，确保精确匹配目标节点
2. 保留位置信息：尽量保留原始代码的位置信息和格式
3. 增量修改：对于大型代码库，考虑增量式修改
4. 测试验证：对转换后的代码进行充分的测试验证

mutatis库结合了Rust强大的类型系统和syn/quote生态，为代码转换任务提供了安全且高效的工具集。