Rust源代码解析库solar-parse使用指南

概述

solar-parse是一个高效的Rust源代码解析库，提供语法分析和抽象语法树(AST)操作功能。它专为需要处理Rust代码的工具(如linter、格式化工具、代码生成器等)设计，具有高性能和易用性的特点。

主要特性

• 完整的Rust语法解析支持
• 高效的解析性能
• 易于遍历和操作的AST结构
• 源代码位置信息保留
• 错误恢复能力

安装

在Cargo.toml中添加依赖：

[dependencies]
solar-parse = "0.4"

基本使用方法

解析Rust代码

use solar_parse::{parse_source, SyntaxTree};

fn main() {
    let code = r#"
        fn main() {
            println!("Hello, world!");
        }
    "#;
    
    let syntax_tree = parse_source(code).expect("Failed to parse code");
    
    // 输出整个语法树
    println!("{:#?}", syntax_tree);
}

遍历AST节点

use solar_parse::{parse_source, visit::Visitor, SyntaxKind};

struct MyVisitor;

impl Visitor for MyVisitor {
    fn visit_node(&mut self, node: &solar_parse::SyntaxNode) {
        if node.kind() == SyntaxKind::FnDef {
            println!("Found function definition at {:?}", node.text_range());
        }
    }
}

fn main() {
    let code = r#"
        fn foo() {}
        fn bar() {}
    "#;
    
    let syntax_tree = parse_source(code).unwrap();
    let mut visitor = MyVisitor;
    syntax_tree.walk(&mut visitor);
}

修改AST

use solar_parse::{parse_source, edit::SyntaxRewriter};

fn main() {
    let code = "fn foo() { let x = 1; }";
    let syntax_tree = parse_source(code).unwrap();
    
    let mut rewriter = SyntaxRewriter::default();
    rewriter.set_rewrite_fn(SyntaxKind::IntLiteral, |node| {
        if node.text() == "1" {
            Some("42".to_string())
        } else {
            None
        }
    });
    
    let new_tree = rewriter.rewrite(&syntax_tree);
    println!("Modified code: {}", new_tree.to_string());
}
// 输出: fn foo() { let x = 42; }

高级用法

错误处理

use solar_parse::{parse_source, ParseError};

fn main() {
    let code = "fn foo() {"; // 不完整的代码
    
    match parse_source(code) {
        Ok(tree) => println!("Parsed successfully"),
        Err(ParseError::IncompleteInput) => eprintln!("Error: Incomplete input"),
        Err(e) => eprintln!("Parse error: {}", e),
    }
}

提取特定语法结构

use solar_parse::{parse_source, SyntaxKind};

fn extract_function_names(code: &str) -> Vec<String> {
    let syntax_tree = parse_source(code).unwrap();
    let mut names = Vec::new();
    
    for node in syntax_tree.descendants() {
        if node.kind() == SyntaxKind::FnDef {
            if let Some(name_node) = node.children().find(|n| n.kind() == SyntaxKind::Ident) {
                names.push(name_node.text().to_string());
            }
        }
    }
    
    names
}

fn main() {
    let code = r#"
        fn foo() {}
        fn bar() {}
    "#;
    
    let names = extract_function_names(code);
    println!("Function names: {:?}", names); // 输出: ["foo", "bar"]
}

性能提示

1. 对于大型代码库，考虑增量解析
2. 重用Parser实例来解析多个文件
3. 只遍历你需要的AST部分

完整示例

以下是一个结合了多个功能的完整示例，展示如何使用solar-parse进行代码解析、遍历、修改和分析：

use solar_parse::{
    parse_source, 
    visit::Visitor, 
    SyntaxKind,
    edit::SyntaxRewriter
};

// 自定义访问器，用于统计函数和变量
struct StatsVisitor {
    function_count: usize,
    variable_count: usize,
}

impl Visitor for StatsVisitor {
    fn visit_node(&mut self, node: &solar_parse::SyntaxNode) {
        match node.kind() {
            SyntaxKind::FnDef => {
                self.function_count += 1;
                println!("Found function: {:?}", node.text_range());
            }
            SyntaxKind::LetStmt => {
                self.variable_count += 1;
                println!("Found variable declaration: {:?}", node.text_range());
            }
            _ => {}
        }
    }
}

fn main() {
    // 示例Rust代码
    let code = r#"
        fn main() {
            let x = 1;
            let y = 2;
            
            fn helper() {
                let z = 3;
            }
        }
    "#;
    
    // 1. 解析代码
    let syntax_tree = parse_source(code).expect("Failed to parse code");
    
    // 2. 使用访问器遍历AST
    let mut visitor = StatsVisitor {
        function_count: 0,
        variable_count: 0,
    };
    syntax_tree.walk(&mut visitor);
    
    println!("Total functions: {}", visitor.function_count);
    println!("Total variables: {}", visitor.variable_count);
    
    // 3. 修改AST - 将所有数字字面量乘以2
    let mut rewriter = SyntaxRewriter::default();
    rewriter.set_rewrite_fn(SyntaxKind::IntLiteral, |node| {
        if let Ok(value) = node.text().parse::<i32>() {
            Some((value * 2).to_string())
        } else {
            None
        }
    });
    
    let modified_tree = rewriter.rewrite(&syntax_tree);
    println!("Modified code:\n{}", modified_tree.to_string());
    
    // 4. 提取函数名
    let function_names = syntax_tree.descendants()
        .filter(|n| n.kind() == SyntaxKind::FnDef)
        .filter_map(|n| {
            n.children()
                .find(|n| n.kind() == SyntaxKind::Ident)
                .map(|n| n.text().to_string())
        })
        .collect::<Vec<_>>();
    
    println!("Function names: {:?}", function_names);
}

这个完整示例展示了：

1. 使用parse_source解析Rust代码
2. 实现自定义访问器Visitor来统计函数和变量数量
3. 使用SyntaxRewriter修改AST节点
4. 遍历AST提取特定信息(函数名)

输出结果将显示：

• 找到的函数和变量数量
• 修改后的代码(所有数字乘以2)
• 提取的函数名列表

solar-parse为Rust代码分析提供了强大的基础，适用于构建各种开发工具和静态分析器。