Oxc AST Visit - 访问者模式实现

概述

Oxc AST Visit crate提供了访问者模式的实现，用于系统性地遍历和修改抽象语法树(AST)节点。它支持两种主要操作模式：不可变访问(Visit)和可变转换(VisitMut)。

主要特性

• 不可变访问 (Visit)：用于分析AST而不修改节点
• 可变访问 (VisitMut)：用于转换和修改AST节点
• 自动生成实现：通过oxc_ast_tools自动生成访问者代码，确保一致性
• UTF编码转换：提供特殊访问者处理UTF-8到UTF-16的span转换

使用示例

1. AST分析示例 (不可变访问)

use oxc_ast::{AstKind, Visit};
use oxc_ast_visit::Visit;

// 自定义访问者结构体
struct FunctionCounter {
    count: usize,
}

impl Visit for FunctionCounter {
    fn enter_node(&mut self, kind: AstKind) {
        if let AstKind::Function(_) = kind {
            self.count += 1;
            println!("Found function #{}", self.count);
        }
    }
}

fn main() {
    // 假设的AST数据
    let ast = get_parsed_ast();
    
    let mut counter = FunctionCounter { count: 0 };
    counter.visit_program(&ast);
    println!("Total functions: {}", counter.count);
}

2. AST转换示例 (可变访问)

use oxc_ast::{AstKind, VisitMut};
use oxc_ast_visit::VisitMut;

// 字符串转换访问者
struct StringTransformer;

impl VisitMut for StringTransformer {
    fn enter_node_mut(&mut self, kind: &mut AstKind) {
        match kind {
            AstKind::StringLiteral(lit) => {
                // 反转所有字符串字面量
                lit.value = lit.value.chars().rev().collect();
            }
            AstKind::TemplateLiteral(lit) => {
                // 在模板字符串前添加注释
                lit.quasis.iter_mut().for_each(|quasi| {
                    quasi.value.raw = format!("/* template */ {}", quasi.value.raw);
                });
            }
            _ => {}
        }
    }
}

fn main() {
    let mut ast = get_parsed_ast();
    let mut transformer = StringTransformer;
    transformer.visit_program_mut(&mut ast);
}

3. 综合使用示例

use oxc_ast::{AstKind, Visit, VisitMut};
use oxc_ast_visit::{Visit, VisitMut};

// 分析阶段：收集所有变量名
struct VariableCollector {
    variables: Vec<String>,
}

impl Visit for VariableCollector {
    fn enter_node(&mut self, kind: AstKind) {
        if let AstKind::Identifier(id) = kind {
            self.variables.push(id.name.clone());
        }
    }
}

// 转换阶段：重命名变量
struct VariableRenamer {
    replacements: std::collections::HashMap<String, String>,
}

impl VisitMut for VariableRenamer {
    fn enter_node_mut(&mut self, kind: &mut AstKind) {
        if let AstKind::Identifier(id) = kind {
            if let Some(new_name) = self.replacements.get(&id.name) {
                id.name = new_name.clone();
            }
        }
    }
}

fn main() {
    let mut ast = get_parsed_ast();
    
    // 第一阶段：分析收集变量
    let mut collector = VariableCollector { variables: Vec::new() };
    collector.visit_program(&ast);
    println!("Found variables: {:?}", collector.variables);
    
    // 第二阶段：创建替换规则
    let mut renamer = VariableRenamer {
        replacements: collector.variables
            .into_iter()
            .map(|var| (var.clone(), format!("{}_renamed", var)))
            .collect(),
    };
    
    // 第三阶段：应用重命名
    renamer.visit_program_mut(&mut ast);
}

高级用法

1. 条件遍历控制

use oxc_ast::{AstKind, Visit};
use oxc_ast_visit::Visit;

struct SelectiveVisitor;

impl Visit for SelectiveVisitor {
    fn enter_node(&mut self, kind: AstKind) -> bool {
        // 只处理函数和变量声明
        matches!(kind, AstKind::Function(_) | AstKind::VariableDeclaration(_))
    }
    
    fn leave_node(&mut self, kind: AstKind) {
        match kind {
            AstKind::Function(func) => {
                println!("Leaving function: {:?}", func.id);
            }
            AstKind::VariableDeclaration(decl) => {
                println!("Leaving variable declaration (kind: {:?})", decl.kind);
            }
            _ => unreachable!(),
        }
    }
}

2. 跨文件分析

use oxc_ast::{AstKind, Visit};
use oxc_ast_visit::Visit;

struct CrossFileAnalyzer {
    file_dependencies: std::collections::HashMap<String, Vec<String>>,
    current_file: String,
}

impl Visit for CrossFileAnalyzer {
    fn enter_node(&mut self, kind: AstKind) {
        if let AstKind::ImportDeclaration(import) = kind {
            self.file_dependencies
                .entry(self.current_file.clone())
                .or_default()
                .push(import.source.value.clone());
        }
    }
}

fn analyze_project(files: &[(&str, &str)]) {
    let mut analyzer = CrossFileAnalyzer {
        file_dependencies: std::collections::HashMap::new(),
        current_file: String::new(),
    };
    
    for (file_name, source) in files {
        analyzer.current_file = file_name.to_string();
        let ast = parse_source(source);
        analyzer.visit_program(&ast);
    }
    
    println!("File dependencies: {:#?}", analyzer.file_dependencies);
}

最佳实践

1. 关注特定节点类型：在访问者实现中，只处理你关心的节点类型，其他节点使用默认处理
2. 分离分析和转换：将分析阶段和转换阶段分离到不同的访问者中
3. 利用自动生成：尽可能使用oxc_ast_tools生成的访问者代码作为基础
4. 性能考虑：对于大型AST，避免在访问者中分配大量临时内存
5. 错误处理：在访问者中妥善处理可能的错误情况

总结

Oxc AST Visit提供了强大的工具来遍历和操作AST，支持从简单的分析到复杂的代码转换等各种场景。通过组合不可变访问和可变访问，可以构建出功能强大且灵活的代码处理工具链。