feat(es/ast): Provide API like magicast

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
  "xtask",
+ "crates/swc_ecma_magicast",
  "crates/swc_core",
  "crates/swc_cli_impl",
  "crates/dbg-swc",
@@ -41,4 +42,4 @@ debug = true
 opt-level = 3
 
 [profile.dev.package."*"]
-opt-level = 3
+opt-level = 3

crates/swc_ecma_magicast/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "swc_ecma_magicast"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+swc_atoms = { version = "0.6.0", path = "../swc_atoms" }
+swc_common = { version = "0.33.0", path = "../swc_common" }
+swc_ecma_ast = { version = "0.110.0", path = "../swc_ecma_ast" }
+swc_ecma_utils = { version = "0.124.7", path = "../swc_ecma_utils" }
+
+[dev-dependencies]
+swc_ecma_parser = { path = "../swc_ecma_parser" }

crates/swc_ecma_magicast/src/data.rs

@@ -0,0 +1,69 @@
+use std::{cell::RefCell, rc::Rc};
+
+use swc_ecma_ast::Program;
+
+/// TODO: Make this generic over the root.
+pub(crate) struct Data<'a, T: 'static>(
+ Rc<RefCell<Program>>,
+ Rc<dyn 'a + Fn(&Program) -> &T>,
+ Rc<dyn 'a + Fn(&mut Program) -> &mut T>,
+);
+
+impl<T: 'static> Clone for Data<'_, T> {
+ fn clone(&self) -> Self {
+ Data(self.0.clone(), self.1.clone(), self.2.clone())
+ }
+}
+
+impl<'a, T: 'static> Data<'a, T> {
+ pub fn new_root(root: Program) -> Data<'a, Program> {
+ Data(
+ Rc::new(RefCell::new(root)),
+ Rc::new(|root| root),
+ Rc::new(|root| root),
+ )
+ }
+
+ pub fn map<N>(
+ &'a self,
+ f1: impl 'a + Fn(&T) -> &N,
+ f2: impl 'a + Fn(&mut T) -> &mut N,
+ ) -> Data<'a, N>
+ where
+ N: 'static,
+ {
+ Data(
+ self.0.clone(),
+ Rc::new(move |data| f1((self.1)(data))),
+ Rc::new(move |data| f2((self.2)(data))),
+ )
+ }
+
+ pub fn map_opt<N>(
+ &'a self,
+ f1: impl 'a + Fn(&T) -> Option<&N>,
+ f2: impl 'a + Fn(&mut T) -> Option<&mut N>,
+ ) -> Option<Data<'a, N>>
+ where
+ N: 'static,
+ {
+ {
+ let data = self.0.borrow();
+ // Check it using actual data
+ f1((self.1)(&data))?;
+ }
+ Some(Data(
+ self.0.clone(),
+ Rc::new(move |data| f1((self.1)(data)).unwrap()),
+ Rc::new(move |data| f2((self.2)(data)).unwrap()),
+ ))
+ }
+
+ pub fn with<Ret>(&self, f: impl FnOnce(&T) -> Ret) -> Ret {
+ f((self.1)(&mut self.0.borrow()))
+ }
+
+ pub fn with_mut<Ret>(&self, f: impl FnOnce(&mut T) -> Ret) -> Ret {
+ f((self.2)(&mut self.0.borrow_mut()))
+ }
+}

crates/swc_ecma_magicast/src/expr.rs

@@ -0,0 +1,36 @@
+use swc_ecma_ast::Expr;
+
+use crate::{data::Data, AstProxyNode, VecNode};
+
+pub struct ArrayNode<'a> {
+ elems: VecNode<SpreadNode<ExprNode<'a>>>,
+}
+
+pub struct ObjectNode {}
+
+pub trait ExprLike {}
+
+#[derive(Clone)]
+pub struct ExprNode<'a>(pub(crate) Data<'a, Box<Expr>>);
+
+impl AstProxyNode for ExprNode<'_> {}
+
+impl<'a> ExprNode<'a> {
+ pub fn cast<T>(&self) -> T
+ where
+ T: ExprLike,
+ {
+ todo!()
+ }
+}
+
+#[derive(Clone)]
+pub struct SpreadNode<T>
+where
+ T: AstProxyNode,
+{
+ has_spread: bool,
+ node: T,
+}
+
+impl<T> AstProxyNode for SpreadNode<T> where T: AstProxyNode {}

crates/swc_ecma_magicast/src/lib.rs

@@ -0,0 +1,44 @@
+use std::ops::{Deref, Shl};
+
+use swc_atoms::Atom;
+use swc_ecma_ast::Program;
+
+use crate::data::Data;
+pub use crate::{expr::*, module::*, option::OptionalNode, traits::*, vec::VecNode};
+#[macro_use]
+mod macros;
+mod data;
+mod expr;
+mod module;
+mod option;
+mod traits;
+mod vec;
+
+#[derive(Clone)]
+pub struct ProgramNode {
+ data: Data<'static, Program>,
+}
+
+impl ProgramNode {
+ pub fn new(root: Program) -> Self {
+ Self {
+ data: Data::<Program>::new_root(root),
+ }
+ }
+
+ /// This will panic if the program is not a module.
+ pub fn as_module(&self) -> ModuleNode {
+ let data = self.data.map(
+ |program| program.as_module().unwrap(),
+ |program| program.as_mut_module().unwrap(),
+ );
+ ModuleNode(data)
+ }
+}
+
+impl AstProxyNode for ProgramNode {}
+
+#[derive(Clone)]
+pub struct BindingRef {
+ sym: Atom,
+}

crates/swc_ecma_magicast/src/macros.rs

@@ -0,0 +1 @@
+