solar-ast: Rust抽象语法树解析库使用指南

简介

solar-ast是一个高效的Rust代码语法分析与AST(抽象语法树)转换库。它允许开发者解析Rust代码并获取其AST表示，便于进行代码分析、转换或生成等操作。

主要特性

• 高效的Rust代码解析能力
• 完整的AST节点类型支持
• 易于使用的API接口
• 支持AST遍历和转换

安装方法

在Cargo.toml中添加依赖：

[dependencies]
solar-ast = "0.1"  # 请使用最新版本

基本使用方法

1. 解析Rust代码为AST

use solar_ast::parse_rust_code;

fn main() {
    let code = r#"
        fn main() {
            println!("Hello, world!");
        }
    "#;
    
    let ast = parse_rust_code(code).expect("Failed to parse Rust code");
    println!("{:#?}", ast);
}

2. 遍历AST节点

use solar_ast::{AstVisitor, visit_ast};

struct MyVisitor;

impl AstVisitor for MyVisitor {
    fn visit_fn(&mut self, fn_decl: &FnDecl) {
        println!("Found function: {}", fn_decl.name);
        // 继续遍历子节点
        visit_fn(self, fn_decl);
    }
}

fn main() {
    let code = "fn foo() {} fn bar() {}";
    let ast = parse_rust_code(code).unwrap();
    
    let mut visitor = MyVisitor;
    visit_ast(&mut visitor, &ast);
}

3. 修改AST并生成代码

use solar_ast::{parse_rust_code, generate_rust_code, AstMutator};

struct MyMutator;

impl AstMutator for MyMutator {
    fn mutate_fn(&mut self, fn_decl: &mut FnDecl) {
        // 为所有函数添加println!
        fn_decl.body.statements.insert(
            0,
            Stmt::Expr(Expr::MacroCall(MacroCall {
                path: "println".into(),
                args: vec!["\"Function called\"".into()],
            })),
        );
    }
}

fn main() {
    let code = "fn example() { /* existing code */ }";
    let mut ast = parse_rust_code(code).unwrap();
    
    let mut mutator = MyMutator;
    mutator.mutate_ast(&mut ast);
    
    let new_code = generate_rust_code(&ast);
    println!("{}", new_code);
}

高级用法

1. 自定义AST处理

use solar_ast::{Expr, visit_expr};

fn count_exprs(ast: &Ast) -> usize {
    let mut count = 0;
    
    visit_expr(&mut |expr: &Expr| {
        count += 1;
        match expr {
            Expr::BinaryOp(_, left, right) => {
                visit_expr(left);
                visit_expr(right);
            }
            // 处理其他表达式类型...
            _ => {}
        }
    }, &ast);
    
    count
}

2. 模式匹配特定语法结构

use solar_ast::{match_ast, Pattern};

fn find_patterns(ast: &Ast) {
    let pattern = Pattern::FnCall {
        name: Pattern::Ident("println"),
        args: Pattern::Any,
    };
    
    match_ast(&ast, &pattern, |matched| {
        println!("Found println! macro at {:?}", matched.span);
    });
}

性能提示

1. 对于大型代码库，考虑增量解析
2. 重用AST节点分配器以提高性能
3. 使用visit_ast_with_context避免重复分配

错误处理

use solar_ast::{ParseError, ParseErrorKind};

match parse_rust_code(code) {
    Ok(ast) => { /* 处理AST */ },
    Err(ParseError { kind, span }) => {
        match kind {
            ParseErrorKind::SyntaxError => eprintln!("Syntax error at {:?}", span),
            ParseErrorKind::UnsupportedFeature => eprintln!("Unsupported feature"),
            // 其他错误类型...
        }
    }
}

完整示例demo

下面是一个完整的示例，展示如何使用solar-ast解析、遍历和修改Rust代码：

use solar_ast::{
    parse_rust_code, 
    generate_rust_code,
    AstVisitor, 
    visit_ast,
    AstMutator,
    FnDecl,
    Stmt,
    Expr,
    MacroCall
};

// 1. 定义AST访问器
struct FunctionCounter {
    count: usize,
}

impl AstVisitor for FunctionCounter {
    fn visit_fn(&mut self, fn_decl: &FnDecl) {
        self.count += 1;
        println!("Found function #{}: {}", self.count, fn_decl.name);
        // 继续遍历子节点
        visit_fn(self, fn_decl);
    }
}

// 2. 定义AST修改器
struct LoggerInjector;

impl AstMutator for LoggerInjector {
    fn mutate_fn(&mut self, fn_decl: &mut FnDecl) {
        // 在每个函数开头添加日志语句
        fn_decl.body.statements.insert(
            0,
            Stmt::Expr(Expr::MacroCall(MacroCall {
                path: "println".into(),
                args: vec![format!("\"Entering function {}\"", fn_decl.name).into()],
            })),
        );
    }
}

fn main() {
    let code = r#"
        fn foo() {
            let x = 1 + 2;
        }
        
        fn bar() {
            println!("Hello");
        }
    "#;
    
    // 1. 解析代码
    let mut ast = parse_rust_code(code).expect("Failed to parse code");
    
    // 2. 遍历AST并统计函数数量
    let mut counter = FunctionCounter { count: 0 };
    visit_ast(&mut counter, &ast);
    println!("Total functions found: {}", counter.count);
    
    // 3. 修改AST
    let mut injector = LoggerInjector;
    injector.mutate_ast(&mut ast);
    
    // 4. 生成新代码
    let new_code = generate_rust_code(&ast);
    println!("Modified code:\n{}", new_code);
}

这个完整示例演示了：

1. 如何解析Rust代码为AST
2. 如何实现自定义的AST访问器来遍历和统计函数
3. 如何实现AST修改器来注入日志语句
4. 如何将修改后的AST重新生成为Rust代码

输出结果会显示：

1. 原代码中的函数列表
2. 注入日志语句后的新代码