| use rustc_hash::{FxHashMap, FxHashSet}; |
| use serde::Deserialize; |
| use swc_core::{ |
| common::{util::take::Take, SyntaxContext, DUMMY_SP}, |
| ecma::{ |
| ast::{ |
| CallExpr, Callee, Decl, Expr, Id, Ident, IdentName, Lit, MemberExpr, MemberProp, |
| Module, ModuleItem, Pat, Script, Stmt, VarDecl, VarDeclKind, VarDeclarator, |
| }, |
| atoms::Atom, |
| utils::{prepend_stmts, private_ident, ExprFactory, IdentRenamer}, |
| visit::{noop_visit_mut_type, noop_visit_type, Visit, VisitMut, VisitMutWith, VisitWith}, |
| }, |
| }; |
|
|
| pub fn cjs_optimizer(config: Config, unresolved_ctxt: SyntaxContext) -> CjsOptimizer { |
| CjsOptimizer { |
| data: State::default(), |
| packages: config.packages, |
| unresolved_ctxt, |
| } |
| } |
|
|
| #[derive(Clone, Debug, Deserialize)] |
| pub struct Config { |
| pub packages: FxHashMap<Atom, PackageConfig>, |
| } |
|
|
| #[derive(Clone, Debug, Deserialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct PackageConfig { |
| pub transforms: FxHashMap<Atom, Atom>, |
| } |
|
|
| pub struct CjsOptimizer { |
| data: State, |
| packages: FxHashMap<Atom, PackageConfig>, |
| unresolved_ctxt: SyntaxContext, |
| } |
|
|
| #[derive(Debug, Default)] |
| struct State { |
| |
| |
| |
| imports: FxHashMap<Id, ImportRecord>, |
|
|
| |
| replaced: FxHashMap<(Atom, Atom), Id>, |
|
|
| extra_stmts: Vec<Stmt>, |
|
|
| rename_map: FxHashMap<Id, Id>, |
|
|
| |
| ignored: FxHashSet<Id>, |
|
|
| is_prepass: bool, |
| } |
|
|
| #[derive(Debug)] |
| struct ImportRecord { |
| module_specifier: Atom, |
| } |
|
|
| impl CjsOptimizer { |
| fn should_rewrite(&self, module_specifier: &Atom) -> Option<&FxHashMap<Atom, Atom>> { |
| self.packages.get(module_specifier).map(|v| &v.transforms) |
| } |
| } |
|
|
| impl VisitMut for CjsOptimizer { |
| noop_visit_mut_type!(); |
|
|
| fn visit_mut_module_items(&mut self, stmts: &mut Vec<ModuleItem>) { |
| self.data.is_prepass = true; |
| stmts.visit_mut_children_with(self); |
| self.data.is_prepass = false; |
| stmts.visit_mut_children_with(self); |
| } |
|
|
| fn visit_mut_expr(&mut self, e: &mut Expr) { |
| e.visit_mut_children_with(self); |
|
|
| if let Expr::Member(n) = e { |
| if let MemberProp::Ident(prop) = &n.prop { |
| if let Expr::Ident(obj) = &*n.obj { |
| let key = obj.to_id(); |
| if self.data.ignored.contains(&key) { |
| return; |
| } |
|
|
| if let Some(record) = self.data.imports.get(&key) { |
| let mut replaced = false; |
|
|
| let new_id = self |
| .data |
| .replaced |
| .entry((record.module_specifier.clone(), prop.sym.clone())) |
| .or_insert_with(|| private_ident!(prop.sym.clone()).to_id()) |
| .clone(); |
|
|
| if let Some(map) = self.should_rewrite(&record.module_specifier) { |
| if let Some(renamed) = map.get(&prop.sym) { |
| replaced = true; |
| if !self.data.is_prepass { |
| |
| let var = VarDeclarator { |
| span: DUMMY_SP, |
| name: Pat::Ident(new_id.clone().into()), |
| init: Some(Box::new(Expr::Member(MemberExpr { |
| span: DUMMY_SP, |
| obj: Box::new(Expr::Call(CallExpr { |
| span: DUMMY_SP, |
| callee: Ident::new( |
| "require".into(), |
| DUMMY_SP, |
| self.unresolved_ctxt, |
| ) |
| .as_callee(), |
| args: vec![Expr::Lit(Lit::Str( |
| renamed.clone().into(), |
| )) |
| .as_arg()], |
| ..Default::default() |
| })), |
| prop: MemberProp::Ident(IdentName::new( |
| prop.sym.clone(), |
| DUMMY_SP, |
| )), |
| }))), |
| definite: false, |
| }; |
|
|
| if !self.data.extra_stmts.iter().any(|s| { |
| if let Stmt::Decl(Decl::Var(v)) = &s { |
| v.decls.iter().any(|d| d.name == var.name) |
| } else { |
| false |
| } |
| }) { |
| self.data.extra_stmts.push(Stmt::Decl(Decl::Var( |
| Box::new(VarDecl { |
| span: DUMMY_SP, |
| kind: VarDeclKind::Const, |
| decls: vec![var], |
| ..Default::default() |
| }), |
| ))); |
| } |
|
|
| *e = Expr::Ident(new_id.into()); |
| } |
| } |
| } |
|
|
| if !replaced { |
| self.data.ignored.insert(key); |
| } |
| } |
| } |
| } |
| } |
| } |
|
|
| fn visit_mut_module(&mut self, n: &mut Module) { |
| n.visit_children_with(&mut Analyzer { |
| data: &mut self.data, |
| in_member_or_var: false, |
| }); |
|
|
| n.visit_mut_children_with(self); |
|
|
| prepend_stmts( |
| &mut n.body, |
| self.data.extra_stmts.drain(..).map(ModuleItem::Stmt), |
| ); |
|
|
| n.visit_mut_children_with(&mut IdentRenamer::new(&self.data.rename_map)); |
| } |
|
|
| fn visit_mut_script(&mut self, n: &mut Script) { |
| n.visit_children_with(&mut Analyzer { |
| data: &mut self.data, |
| in_member_or_var: false, |
| }); |
|
|
| n.visit_mut_children_with(self); |
|
|
| prepend_stmts(&mut n.body, self.data.extra_stmts.drain(..)); |
|
|
| n.visit_mut_children_with(&mut IdentRenamer::new(&self.data.rename_map)); |
| } |
|
|
| fn visit_mut_stmt(&mut self, n: &mut Stmt) { |
| n.visit_mut_children_with(self); |
|
|
| if let Stmt::Decl(Decl::Var(v)) = n { |
| if v.decls.is_empty() { |
| n.take(); |
| } |
| } |
| } |
|
|
| fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator) { |
| n.visit_mut_children_with(self); |
|
|
| |
| if let Some(Expr::Call(CallExpr { |
| callee: Callee::Expr(callee), |
| args, |
| .. |
| })) = n.init.as_deref() |
| { |
| if let Expr::Ident(ident) = &**callee { |
| if ident.ctxt == self.unresolved_ctxt && ident.sym == *"require" { |
| if let Some(arg) = args.first() { |
| if let Expr::Lit(Lit::Str(v)) = &*arg.expr { |
| |
|
|
| if let Pat::Ident(name) = &n.name { |
| if self.should_rewrite(&v.value).is_some() { |
| let key = name.to_id(); |
|
|
| if !self.data.is_prepass { |
| if !self.data.ignored.contains(&key) { |
| |
| n.name.take(); |
| } |
| } else { |
| self.data.imports.insert( |
| key, |
| ImportRecord { |
| module_specifier: v.value.clone(), |
| }, |
| ); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
|
|
| fn visit_mut_var_declarators(&mut self, n: &mut Vec<VarDeclarator>) { |
| n.visit_mut_children_with(self); |
|
|
| |
| n.retain(|v| !v.name.is_invalid()); |
| } |
| } |
|
|
| struct Analyzer<'a> { |
| in_member_or_var: bool, |
| data: &'a mut State, |
| } |
|
|
| impl Visit for Analyzer<'_> { |
| noop_visit_type!(); |
|
|
| fn visit_var_declarator(&mut self, n: &VarDeclarator) { |
| let mut safe_to_ignore = false; |
|
|
| |
| if let Some(Expr::Call(CallExpr { |
| callee: Callee::Expr(callee), |
| .. |
| })) = n.init.as_deref() |
| { |
| if let Expr::Ident(ident) = &**callee { |
| if ident.sym == *"require" { |
| safe_to_ignore = true; |
| } |
| } |
| } |
|
|
| if safe_to_ignore { |
| self.in_member_or_var = true; |
| n.visit_children_with(self); |
| self.in_member_or_var = false; |
| } else { |
| n.visit_children_with(self); |
| } |
| } |
|
|
| fn visit_member_expr(&mut self, e: &MemberExpr) { |
| self.in_member_or_var = true; |
| e.visit_children_with(self); |
| self.in_member_or_var = false; |
|
|
| if let (Expr::Ident(obj), MemberProp::Computed(..)) = (&*e.obj, &e.prop) { |
| self.data.ignored.insert(obj.to_id()); |
| } |
| } |
|
|
| fn visit_ident(&mut self, i: &Ident) { |
| i.visit_children_with(self); |
| if !self.in_member_or_var { |
| self.data.ignored.insert(i.to_id()); |
| } |
| } |
| } |
|
|
