Rust ECMAScript兼容库swc_ecma_compat_es2017的使用指南

概述

swc_ecma_compat_es2017是一个基于Rust的ECMAScript兼容库，专门用于将ES2017及更高版本的JavaScript代码转换为向后兼容的语法。该库是SWC（Speedy Web Compiler）生态系统的一部分，提供高效的代码转换和语法降级功能。

主要特性

• 支持ES2017语法特性的识别和转换
• 提供完整的AST操作接口
• 高性能的代码转换能力
• 支持自定义转换规则配置

安装方法

在Cargo.toml中添加依赖：

[dependencies]
swc_ecma_compat_es2017 = "0.1.0"
swc_ecma_parser = "0.1.0"
swc_ecma_codegen = "0.1.0"

基本使用方法

1. 简单代码转换示例

use swc_ecma_compat_es2017::es2017;
use swc_ecma_parser::{Parser, StringInput, Syntax};
use swc_ecma_codegen::text_writer::JsWriter;
use swc_ecma_ast::Module;

fn main() {
    let code = r#"
        async function fetchData() {
            const response = await fetch('/api/data');
            const data = await response.json();
            return data;
        }
    "#;

    // 解析代码
    let mut parser = Parser::new(
        Syntax::Es(Default::default()),
        StringInput::new(code, Default::default()),
        None
    );
    
    let module = parser.parse_module().unwrap();
    
    // 应用ES2017转换
    let transformed = es2017().apply(module);
    
    // 生成转换后的代码
    let mut buf = Vec::new();
    let mut emitter = swc_ecma_codegen::Emitter {
        cfg: Default::default(),
        cm: Default::default(),
        comments: None,
        wr: JsWriter::new(Default::default(), "\n", &mut buf, None),
    };
    
    emitter.emit_module(&transformed).unwrap();
    
    let result = String::from_utf8(buf).unwrap();
    println!("{}", result);
}

2. 配置转换选项

use swc_ecma_compat_es2017::{es2017, Config};

fn configure_transformer() {
    let config = Config {
        // 启用特定的转换功能
        async_await: true,
        trailing_commas: true,
        object_rest_spread: true,
        // 其他配置选项...
    };
    
    let transformer = es2017().config(config);
    // 使用配置好的转换器...
}

3. 处理特定语法特性

use swc_ecma_compat_es2017::es2017;
use swc_ecma_visit::VisitMutWith;

fn transform_specific_features() {
    let code = r#"
        const obj = { a: 1, b: 2 };
        const { a, ...rest } = obj;
        
        const arr = [1, 2, 3];
        const [first, ...others] = arr;
    "#;
    
    // 解析和转换代码
    let mut parser = Parser::new(
        Syntax::Es(Default::default()),
        StringInput::new(code, Default::default()),
        None
    );
    
    let mut module = parser.parse_module().unwrap();
    
    // 只转换对象展开和数组展开语法
    let transformer = es2017();
    module.visit_mut_with(&mut transformer);
    
    // 输出转换结果...
}

高级用法

自定义访问器

use swc_ecma_compat_es2017::es2017;
use swc_ecma_visit::{VisitMut, VisitMutWith};

struct CustomVisitor;

impl VisitMut for CustomVisitor {
    // 实现自定义的访问逻辑
}

fn custom_transformation() {
    let mut transformer = es2017();
    
    // 添加自定义访问器
    let mut custom_visitor = CustomVisitor;
    transformer.visit_mut = Some(Box::new(custom_visitor));
    
    // 使用增强的转换器...
}

批量处理多个文件

use std::fs;
use swc_ecma_compat_es2017::es2017;

fn process_directory(dir_path: &str) {
    let transformer = es2017();
    
    for entry in fs::read_dir(dir_path).unwrap() {
        let entry = entry.unwrap();
        if entry.path().extension().unwrap() == "js" {
            let content = fs::read_to_string(entry.path()).unwrap();
            
            // 解析和转换每个文件
            let mut parser = Parser::new(
                Syntax::Es(Default::default()),
                StringInput::new(&content, Default::default()),
                None
            );
            
            let mut module = parser.parse_module().unwrap();
            module.visit_mut_with(&mut transformer);
            
            // 保存转换结果...
        }
    }
}

注意事项

1. 确保输入的JavaScript代码语法正确
2. 转换过程可能会改变代码结构，建议进行充分测试
3. 对于大型项目，考虑使用增量转换策略
4. 注意内存使用情况，特别是在处理大型文件时

错误处理

use swc_common::errors::Handler;

fn safe_transformation() -> Result<String, Box<dyn std::error::Error>> {
    let code = "async function test() { await Promise.resolve(); }";
    
    let handler = Handler::with_tty_emitter();
    let mut parser = Parser::new(
        Syntax::Es(Default::default()),
        StringInput::new(code, Default::default()),
        Some(&handler)
    );
    
    match parser.parse_module() {
        Ok(mut module) => {
            let transformer = es2017();
            module.visit_mut_with(&mut transformer);
            Ok("转换成功".to_string())
        },
        Err(e) => Err(Box::new(e))
    }
}

完整示例demo

use swc_ecma_compat_es2017::{es2017, Config};
use swc_ecma_parser::{Parser, StringInput, Syntax};
use swc_ecma_codegen::text_writer::JsWriter;
use swc_ecma_ast::Module;
use swc_ecma_visit::VisitMutWith;
use std::fs;
use std::io::Write;

// 完整的ES2017转换示例
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 示例1: 基本转换
    basic_transformation()?;
    
    // 示例2: 配置转换选项
    configured_transformation()?;
    
    // 示例3: 批量处理文件
    batch_process_files("./src")?;
    
    Ok(())
}

// 基本转换函数
fn basic_transformation() -> Result<(), Box<dyn std::error::Error>> {
    let code = r#"
        // ES2017特性示例
        async function getUserData(userId) {
            try {
                const response = await fetch(`/api/users/${userId}`);
                const data = await response.json();
                
                // 对象展开运算符
                const { name, email, ...metadata } = data;
                
                // 数组展开运算符
                const [firstItem, ...remainingItems] = data.items;
                
                return { name, email, metadata, remainingItems };
            } catch (error) {
                console.error('获取用户数据失败:', error);
                throw error;
            }
        }
        
        // 异步箭头函数
        const processData = async (data) => {
            const processed = await data.process();
            return processed;
        };
    "#;

    println!("原始代码:");
    println!("{}", code);
    println!("\n转换后的代码:");

    // 创建解析器
    let mut parser = Parser::new(
        Syntax::Es(Default::default()),
        StringInput::new(code, Default::default()),
        None
    );
    
    // 解析模块
    let module = parser.parse_module()?;
    
    // 应用ES2017转换
    let transformed = es2017().apply(module);
    
    // 生成转换后的代码
    let mut buf = Vec::new();
    let mut emitter = swc_ecma_codegen::Emitter {
        cfg: Default::default(),
        cm: Default::default(),
        comments: None,
        wr: JsWriter::new(Default::default(), "\n", &mut buf, None),
    };
    
    emitter.emit_module(&transformed)?;
    
    let result = String::from_utf8(buf)?;
    println!("{}", result);
    
    Ok(())
}

// 配置转换选项的示例
fn configured_transformation() -> Result<(), Box<dyn std::error::Error>> {
    let code = r#"
        const config = {
            apiUrl: 'https://api.example.com',
            timeout: 5000,
            retries: 3,
        };
        
        const { apiUrl, ...options } = config;
        
        async function fetchWithRetry(url, options) {
            for (let i = 0; i < options.retries; i++) {
                try {
                    const response = await fetch(url, options);
                    return await response.json();
                } catch (error) {
                    if (i === options.retries - 1) throw error;
                    await new Promise(resolve => setTimeout(resolve, 1000));
                }
            }
        }
    "#;

    // 配置转换器
    let config = Config {
        async_await: true,          // 启用async/await转换
        object_rest_spread: true,    // 启用对象展开运算符转换
        trailing_commas: false,      // 禁用尾随逗号转换
        // 其他配置选项...
    };
    
    let transformer = es2017().config(config);
    
    // 解析和转换
    let mut parser = Parser::new(
        Syntax::Es(Default::default()),
        StringInput::new(code, Default::default()),
        None
    );
    
    let mut module = parser.parse_module()?;
    module.visit_mut_with(&mut transformer);
    
    // 生成转换后的代码
    let mut buf = Vec::new();
    let mut emitter = swc_ecma_codegen::Emitter {
        cfg: Default::default(),
        cm: Default::default(),
        comments: None,
        wr: JsWriter::new(Default::default(), "\n", &mut buf, None),
    };
    
    emitter.emit_module(&module)?;
    
    let result = String::from_utf8(buf)?;
    println!("配置转换后的代码:");
    println!("{}", result);
    
    Ok(())
}

// 批量处理文件的示例
fn batch_process_files(dir_path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let transformer = es2017();
    
    // 创建输出目录
    let output_dir = "./output";
    fs::create_dir_all(output_dir)?;
    
    // 遍历目录中的JavaScript文件
    for entry in fs::read_dir(dir_path)? {
        let entry = entry?;
        let path = entry.path();
        
        if path.extension().map(|ext| ext == "js").unwrap_or(false) {
            println!("处理文件: {:?}", path);
            
            // 读取文件内容
            let content = fs::read_to_string(&path)?;
            
            // 解析代码
            let mut parser = Parser::new(
                Syntax::Es(Default::default()),
                StringInput::new(&content, Default::default()),
                None
            );
            
            let mut module = match parser.parse_module() {
                Ok(module) => module,
                Err(e) => {
                    eprintln!("解析文件 {:?} 失败: {}", path, e);
                    continue;
                }
            };
            
            // 应用转换
            module.visit_mut_with(&mut transformer);
            
            // 生成转换后的代码
            let mut buf = Vec::new();
            let mut emitter = swc_ecma_codegen::Emitter {
                cfg: Default::default(),
                cm: Default::default(),
                comments: None,
                wr: JsWriter::new(Default::default(), "\n", &mut buf, None),
            };
            
            if let Err(e) = emitter.emit_module(&module) {
                eprintln!("生成代码失败: {}", e);
                continue;
            }
            
            // 保存转换结果
            let output_path = output_dir.join(path.file_name().unwrap());
            let mut output_file = fs::File::create(output_path)?;
            output_file.write_all(&buf)?;
            
            println!("文件转换完成并保存");
        }
    }
    
    Ok(())
}

// 错误处理示例
fn safe_transformation_with_error_handling() -> Result<String, Box<dyn std::error::Error>> {
    let code = r#"
        // 包含语法错误的代码
        async function test() { 
            await Promise.resolve()
            // 缺少分号
            console.log("Done")
        }
    "#;
    
    use swc_common::errors::Handler;
    
    let handler = Handler::with_tty_emitter();
    let mut parser = Parser::new(
        Syntax::Es(Default::default()),
        StringInput::new(code, Default::default()),
        Some(&handler)
    );
    
    match parser.parse_module() {
        Ok(mut module) => {
            let transformer = es2017();
            module.visit_mut_with(&mut transformer);
            
            // 生成转换后的代码
            let mut buf = Vec::new();
            let mut emitter = swc_ecma_codegen::Emitter {
                cfg: Default::default(),
                cm: Default::default(),
                comments: None,
                wr: JsWriter::new(Default::default(), "\n", &mut buf, None),
            };
            
            emitter.emit_module(&module)?;
            
            Ok(String::from_utf8(buf)?)
        },
        Err(e) => {
            Err(Box::new(e))
        }
    }
}

这个库为处理ES2017代码的向后兼容性提供了强大的工具集，特别适合在需要支持旧版JavaScript环境的项目中。通过上述示例，您可以了解如何使用swc_ecma_compat_es2017进行基本的代码转换、配置转换选项、批量处理文件以及处理转换过程中可能出现的错误。