feat: Add experimental babel plugin runner

Cargo.toml

@@ -70,6 +70,7 @@ testing                     = "5.0.0"
 tracing                     = "0.1.40"
 widestring                  = "1.0.2"
 
+rquickjs                     = "0.8.1"
 rustc-hash                   = "2.1.0"
 swc_icu_messageformat_parser = { version = "1.0.0", path = "./crates/swc_icu_messageformat_parser" }
 

crates/swc_experimental_babel/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+
+description = "AST Transforms for experimental babel plugin"
+
+name = "swc_experimental_babel"
+
+authors      = { workspace = true }
+edition      = { workspace = true }
+homepage     = { workspace = true }
+license      = { workspace = true }
+repository   = { workspace = true }
+rust-version = { workspace = true }
+version      = "0.1.0"
+
+[dependencies]
+anyhow           = { workspace = true }
+once_cell        = { workspace = true }
+rquickjs         = { workspace = true }
+serde            = { workspace = true, features = ["derive"] }
+swc_atoms        = { workspace = true }
+swc_common       = { workspace = true }
+swc_core         = { workspace = true, features = [] }
+swc_ecma_ast     = { workspace = true }
+swc_ecma_codegen = { workspace = true }
+swc_ecma_parser  = { workspace = true }
+swc_ecma_visit   = { workspace = true }
+
+[dev-dependencies]
+swc_ecma_parser             = { workspace = true }
+swc_ecma_transforms_base    = { workspace = true }
+swc_ecma_transforms_testing = { workspace = true }
+testing                     = { workspace = true }

crates/swc_experimental_babel/src/lib.rs

@@ -0,0 +1,149 @@
+use anyhow::{Context as _, Result};
+use rquickjs::{function::Args, FromJs, Function, IntoJs, Module};
+use serde::{Deserialize, Serialize};
+use swc_common::{sync::Lrc, FileName, SourceMap, SourceMapper};
+use swc_ecma_ast::{EsVersion, Pass, Program, SourceMapperExt};
+use swc_ecma_codegen::{text_writer::JsWriter, Emitter, Node};
+use swc_ecma_parser::parse_file_as_program;
+
+use crate::qjs::with_quickjs_context;
+
+mod qjs;
+
+pub struct Transform<'a, S>
+where
+    S: SourceMapper + SourceMapperExt,
+{
+    pub transform_code: &'a str,
+    pub cm: Lrc<S>,
+    pub filename: Lrc<FileName>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct TransformOutput {
+    pub code: String,
+    #[serde(default)]
+    pub map: Option<String>,
+}
+
+impl TransformOutput {
+    pub fn from_swc<S>(cm: Lrc<S>, program: &Program) -> Result<Self>
+    where
+        S: SourceMapper + SourceMapperExt,
+    {
+        let dummy_cm = Lrc::new(SourceMap::default());
+        let mut buf = vec![];
+
+        {
+            let mut wr = JsWriter::new(dummy_cm, "\n", &mut buf, None);
+            let mut emitter = Emitter {
+                cfg: Default::default(),
+                cm,
+                comments: None,
+                wr: &mut wr,
+            };
+
+            program.emit_with(&mut emitter)?;
+        }
+
+        Ok(Self {
+            code: String::from_utf8(buf).context("failed to convert the generated code to utf8")?,
+            map: None,
+        })
+    }
+
+    pub fn parse(self, filename: Lrc<FileName>) -> Result<Program> {
+        let cm = Lrc::new(SourceMap::default());
+        let fm = cm.new_source_file(filename, self.code);
+
+        let program = parse_file_as_program(
+            &fm,
+            Default::default(),
+            EsVersion::latest(),
+            None,
+            &mut vec![],
+        )
+        .map_err(|err| anyhow::anyhow!("failed to parse the file: {:?}", err))?;
+
+        Ok(program)
+    }
+}
+
+impl<S> Transform<'_, S>
+where
+    S: SourceMapper + SourceMapperExt,
+{
+    fn apply_transform(&self, input: TransformOutput) -> Result<TransformOutput> {
+        with_quickjs_context(|ctx| {
+            dbg!("declaring module", &self.transform_code);
+
+            let module = Module::declare(ctx.clone(), "babel-transform", self.transform_code)
+                .context("failed to declare the module")?
+                .eval()
+                .context("failed to evaluate the module")?
+                .0;
+
+            dbg!("declared module");
+
+            let function: Function = module
+                .get("transform")
+                .context("failed to get the default export")?;
+
+            dbg!("got function");
+
+            let mut args = Args::new(ctx.clone(), 1);
+            args.push_arg(input)?;
+
+            let output = function
+                .call_arg(args)
+                .context("failed to call the transform function")?;
+
+            Ok(output)
+        })
+    }
+}
+
+impl<S> Pass for Transform<'_, S>
+where
+    S: SourceMapper + SourceMapperExt,
+{
+    fn process(&mut self, program: &mut Program) {
+        let input = TransformOutput::from_swc(self.cm.clone(), program)
+            .expect("failed to convert swc program to babel input");
+        let output = self
+            .apply_transform(input)
+            .expect("failed to apply the babel transform");
+
+        let new_program = output
+            .parse(self.filename.clone())
+            .expect("failed to parse the output");
+
+        *program = new_program;
+    }
+}
+
+impl<'a> IntoJs<'a> for TransformOutput {
+    fn into_js(self, ctx: &rquickjs::Ctx<'a>) -> rquickjs::Result<rquickjs::Value<'a>> {
+        let obj = rquickjs::Object::new(ctx.clone())?;
+
+        obj.set("code", self.code)?;
+        obj.set("map", self.map)?;
+
+        obj.into_js(ctx)
+    }
+}
+
+impl<'a> FromJs<'a> for TransformOutput {
+    fn from_js(_: &rquickjs::Ctx<'a>, value: rquickjs::Value<'a>) -> rquickjs::Result<Self> {
+        let obj = value.into_object().ok_or_else(|| rquickjs::Error::FromJs {
+            from: "Value",
+            to: "Object",
+            message: Some("expected an object".to_string()),
+        })?;
+
+        Ok(Self {
+            code: obj.get::<_, String>("code")?,
+            map: obj.get::<_, Option<String>>("map")?,
+        })
+    }
+}

crates/swc_experimental_babel/src/qjs.rs

@@ -0,0 +1,19 @@
+use once_cell::unsync::Lazy;
+use rquickjs::{Context, Runtime};
+
+thread_local! {
+    static QUICKJS_RUNTIME: Lazy<Runtime> = Lazy::new(|| Runtime::new().expect("failed to create quickjs runtime"));
+}
+
+thread_local! {
+    static QUICKJS_CONTEXT: Lazy<Context> = Lazy::new(|| {
+        QUICKJS_RUNTIME.with(|rt| Context::full(rt).expect("failed to create context"))
+    });
+}
+
+pub fn with_quickjs_context<F, R>(f: F) -> R
+where
+    F: FnOnce(rquickjs::Ctx) -> R,
+{
+    QUICKJS_CONTEXT.with(|ctx| ctx.with(f))
+}

crates/swc_experimental_babel/tests/basic-transform.js

@@ -0,0 +1,10 @@
+
+
+export function transform({ code, map }) {
+
+
+    return {
+        code: code + ';\nconsole.log("hello")',
+        map,
+    };
+}

crates/swc_experimental_babel/tests/basic/basic/input.js

@@ -0,0 +1,5 @@
+import { createContext } from 'preact';
+
+export function aaa() {
+  const context = createContext();
+}

crates/swc_experimental_babel/tests/basic/basic/output.js

@@ -0,0 +1,6 @@
+import { createContext } from 'preact';
+export function aaa() {
+    const context = createContext();
+}
+;
+console.log("hello");

crates/swc_experimental_babel/tests/fixture.rs

@@ -0,0 +1,31 @@
+use std::path::PathBuf;
+
+use swc_common::{sync::Lrc, FileName, Mark};
+use swc_ecma_transforms_base::resolver;
+use swc_ecma_transforms_testing::test_fixture;
+
+#[testing::fixture("tests/basic/**/input.js")]
+
+fn fixture(input: PathBuf) {
+    let output = input
+        .parent()
+        .expect("should have parent directory")
+        .join("output.js");
+
+    test_fixture(
+        Default::default(),
+        &|tr| {
+            (
+                resolver(Mark::new(), Mark::new(), false),
+                swc_experimental_babel::Transform {
+                    transform_code: include_str!("./basic-transform.js"),
+                    filename: Lrc::new(FileName::Real(input.clone())),
+                    cm: tr.cm.clone(),
+                },
+            )
+        },
+        &input,
+        &output,
+        Default::default(),
+    );
+}