Rust语法树处理库ast-grep-core的使用指南

ast-grep-core是一个强大的Rust库，用于在语法树级别进行代码搜索、转换和模式匹配。它提供了一种高效的方式来分析和操作源代码，特别适合构建代码重构工具、linter或代码分析器。

主要特性

• 基于语法树(Abstract Syntax Tree)的精确匹配
• 支持多种编程语言(通过tree-sitter)
• 高性能的代码搜索和转换
• 灵活的模式匹配规则

基本使用方法

添加依赖

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

[dependencies]
ast-grep-core = "0.10"

基本示例：搜索代码模式

use ast_grep_core::{AstGrep, Language, Pattern};

fn main() {
    // 选择语言(这里使用JavaScript作为示例)
    let lang = Language::JavaScript;
    
    // 要分析的源代码
    let source = r#"
        function greet(name) {
            return "Hello, " + name;
        }
    "#;
    
    // 创建语法树
    let grep = AstGrep::new(source, lang);
    
    // 定义要搜索的模式
    let pattern = Pattern::new("$A + $B", lang);
    
    // 搜索匹配项
    let matches = grep.root().find_all(&pattern);
    
    // 打印结果
    for node in matches {
        println!("Found: {}", node.text());
    }
}

代码转换示例

use ast_grep_core::{AstGrep, Language, Pattern, Replacer};

fn main() {
    let lang = Language::JavaScript;
    let source = r#"
        function add(a, b) {
            return a + b;
        }
    "#;
    
    let grep = AstGrep::new(source, lang);
    let pattern = Pattern::new("$A + $B", lang);
    let replacer = Replacer::new("add($A, $B)", lang);
    
    // 替换所有匹配的模式
    let transformed = grep.root().replace_all(&pattern, &replacer);
    
    println!("Transformed code:\n{}", transformed.text());
}

高级用法

使用规则文件

ast-grep支持使用YAML文件定义复杂的匹配规则：

# rule.yml
id: console-log
message: Avoid using console.log
severity: warning
language: JavaScript
rule:
  pattern: console.log($A)

然后在Rust代码中加载规则：

use ast_grep_core::{Rule, Language};

fn main() {
    let rule = Rule::from_yaml_file("rule.yml").unwrap();
    let lang = Language::JavaScript;
    let source = r#"console.log('test');"#;
    
    let grep = AstGrep::new(source, lang);
    let matches = grep.root().find(&rule.matcher);
    
    if let Some(node) = matches {
        println!("Found violation: {}", node.text());
    }
}

自定义语言支持

ast-grep使用tree-sitter作为语法分析后端，可以扩展支持更多语言：

use ast_grep_core::{Language, Parser};

fn main() {
    // 加载自定义的tree-sitter语法
    let parser = Parser::new("path/to/tree-sitter-grammar");
    let lang = Language::from_parser(parser);
    
    // 现在可以使用自定义语言进行分析
    let grep = AstGrep::new("your source code", lang);
    // ...
}

性能提示

• 对于大型代码库，考虑重用AstGrep实例
• 复杂的模式匹配可能会影响性能，尽量简化规则
• 批量处理多个文件时，可以使用并行处理

ast-grep-core为Rust开发者提供了强大的代码分析和操作能力，特别适合构建代码质量工具或自动化重构工具。

完整示例demo

下面是一个结合搜索和转换的完整示例，展示如何使用ast-grep-core进行复杂的代码重构：

use ast_grep_core::{AstGrep, Language, Pattern, Replacer, Rule};

// 定义一个规则来检测和转换旧的Promise使用方式
fn main() {
    // 1. 定义YAML规则内容
    let rule_yaml = r#"
id: old-promise
message: Convert old Promise style to async/await
severity: warning
language: JavaScript
rule:
  pattern: new Promise($FUNC)
"#;

    // 2. 从字符串创建规则
    let rule = Rule::from_yaml(rule_yaml).unwrap();
    let lang = Language::JavaScript;
    
    // 3. 要转换的示例代码
    let source = r#"
function fetchData() {
    return new Promise((resolve, reject) => {
        // 模拟异步操作
        setTimeout(() => {
            resolve("Data loaded");
        }, 1000);
    });
}
    "#;
    
    // 4. 创建语法树
    let grep = AstGrep::new(source, lang);
    
    // 5. 查找所有匹配的Promise表达式
    let matches = grep.root().find_all(&rule.matcher);
    
    // 6. 定义转换器
    let pattern = Pattern::new("new Promise($FUNC)", lang);
    let replacer = Replacer::new("async function() {\n    await $FUNC\n}", lang);
    
    // 7. 应用转换
    let mut transformed = source.to_string();
    for node in matches {
        let result = node.replace(&pattern, &replacer);
        transformed = result.text().to_string();
    }
    
    println!("Original code:\n{}", source);
    println!("\nTransformed code:\n{}", transformed);
}

这个完整示例展示了：

1. 如何从YAML字符串创建规则
2. 如何搜索特定的语法模式(Promise构造函数)
3. 如何将找到的模式转换为async/await语法
4. 整个过程保持了原始代码的结构和格式

你可以根据需要修改规则和转换逻辑，应用于不同的代码重构场景。