crates/core/src/rules/un_esm.rs
GitHubuse std::collections::{hash_map::Entry, HashMap, HashSet};
use swc_core::atoms::Atom;
use swc_core::common::{Mark, Span, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
ArrowExpr, AssignExpr, AssignOp, AssignTarget, BinaryOp, BindingIdent, BlockStmt,
BlockStmtOrExpr, CallExpr, Callee, CondExpr, Decl, ExportDecl, ExportDefaultExpr,
ExportNamedSpecifier, ExportSpecifier, Expr, ExprStmt, ForHead, ForInStmt, Ident, IdentName,
ImportDecl, ImportDefaultSpecifier, ImportNamedSpecifier, ImportSpecifier, Lit, MemberExpr,
MemberProp, Module, ModuleDecl, ModuleExportName, ModuleItem, NamedExport, ObjectPatProp,
OptChainBase, Pat, Prop, PropName, PropOrSpread, ReturnStmt, SeqExpr, SimpleAssignTarget, Stmt,
Str, UnaryOp, VarDecl, VarDeclKind, VarDeclarator,
};
use swc_core::ecma::utils::{find_pat_ids, ExprFactory};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};
use crate::analysis::binding_uses::{BindingId, BindingUseIndex};
use crate::utils::paren::strip_parens;
use super::decl_utils::{collect_decl_names, collect_pat_names, same_ident};
use super::rename_utils::{rename_bindings, BindingRename};
use super::RewriteLevel;
pub struct UnEsm {
unresolved_mark: Mark,
level: RewriteLevel,
}
impl UnEsm {
pub fn new(unresolved_mark: Mark, level: RewriteLevel) -> Self {
Self {
unresolved_mark,
level,
}
}
}
// ============================================================
// Classification types
// ============================================================
/// Classified CJS require kinds
enum CjsRequireKind {
/// require('foo') bare statement → import 'foo'
Bare { source: String },
/// var foo = require('foo') → import foo from 'foo'
Default { local: Ident, source: String },
/// var { a, b: c } = require('foo') → import { a, b as c } from 'foo'
Named {
specifiers: Vec<(Atom, Ident)>,
source: String,
},
/// var foo = require('foo').default → import foo from 'foo'
DefaultProp { local: Ident, source: String },
/// var foo = require('foo').bar → import { bar as foo } from 'foo'
NamedProp {
prop: Atom,
local: Ident,
source: String,
},
}
/// Classified CJS export kinds
enum CjsExportKind {
/// Object.defineProperty(exports, "__esModule", ...) marker → remove
EsModuleFlag,
/// module.exports = expr → export default expr
ModuleExportsDefault { expr: Box<Expr> },
/// exports.foo = expr or module.exports.foo = expr
Named {
name: Atom,
expr: Box<Expr>,
is_void: bool,
},
/// exports.default = expr → export default expr
NamedDefault { expr: Box<Expr> },
/// `Object.defineProperty(exports, "name", { get: () => dep.member })`
/// where `dep` is a stable top-level `require("source")` binding.
ReExport {
name: Atom,
imported: Atom,
source: String,
binding: BindingId,
},
/// exports.default = expr; module.exports = exports.default → keep the real default
DefaultMirror,
/// module.exports.default = module.exports pattern → remove
SelfRef,
}
/// Classification of a module item
enum Classified {
ExistingImport(ImportDecl),
CjsRequire(CjsRequireKind),
CjsExport { span: Span, kind: CjsExportKind },
Keep(ModuleItem),
}
/// Per-source import accumulator — stores full Ident to preserve SyntaxContext
#[derive(Default)]
struct SourceEntry {
first_default: Option<Ident>,
named: Vec<(Atom, Ident)>, // (imported_name, local_ident)
extra_defaults: Vec<Ident>,
bare: bool,
/// Whether any CJS require() was found for this source.
/// If false, existing import declarations can be passed through unchanged.
has_cjs: bool,
/// Original ImportDecl(s) for this source (used when has_cjs=false)
original_imports: Vec<ImportDecl>,
}
impl SourceEntry {
fn add_default(&mut self, local: Ident) {
if self.first_default.is_none() {
self.first_default = Some(local);
} else {
self.extra_defaults.push(local);
}
}
fn add_named(&mut self, imported: Atom, local: Ident) {
// dedup by local sym
if !self.named.iter().any(|(_, l)| l.sym == local.sym) {
self.named.push((imported, local));
}
}
fn set_bare(&mut self) {
self.bare = true;
}
}
// ============================================================
// Main implementation
// ============================================================
impl VisitMut for UnEsm {
fn visit_mut_module(&mut self, module: &mut swc_core::ecma::ast::Module) {
if self.level < RewriteLevel::Standard {
return;
}
// Phase -1: hoist require() calls out of complex expressions
hoist_embedded_requires(module, self.unresolved_mark);
// Phase 0: split compound `var s = exports.X = expr` →
// `var s = expr; exports.X = s;`
split_compound_exports(module, self.unresolved_mark);
rewrite_webpack_export_getters(module, self.unresolved_mark);
lower_exported_cjs_requires(module, self.unresolved_mark);
let all_declared_names = collect_all_declared_names(module);
let binding_uses = BindingUseIndex::collect(module);
let require_bindings =
collect_stable_require_bindings(module, &binding_uses, self.unresolved_mark);
let items = std::mem::take(&mut module.body);
// Phase 1: classify
let mut classified: Vec<Classified> = Vec::with_capacity(items.len());
for item in items {
classified.push(classify_item(item, self.unresolved_mark, &require_bindings));
}
// Webpack/Babel interop often emits:
// exports.default = value;
// module.exports = exports.default;
// The second assignment only mirrors the CommonJS shape. If treated as
// the last default export, it strands the real value as a side-effect.
remove_default_export_mirrors(&mut classified, self.unresolved_mark);
// Phase 2: export dedup
struct ExportEntry {
classified_idx: usize,
name: Option<Atom>, // None = default
is_void: bool,
}
let mut export_entries: Vec<ExportEntry> = Vec::new();
for (idx, c) in classified.iter().enumerate() {
if let Classified::CjsExport { kind, .. } = c {
let (name, is_void) = match kind {
CjsExportKind::EsModuleFlag => continue,
CjsExportKind::ModuleExportsDefault { .. } => (None, false),
CjsExportKind::NamedDefault { .. } => (None, false),
CjsExportKind::ReExport { name, .. } => {
((name.as_ref() != "default").then(|| name.clone()), false)
}
CjsExportKind::Named { name, is_void, .. } => {
((name.as_ref() != "default").then(|| name.clone()), *is_void)
}
CjsExportKind::DefaultMirror => {
export_entries.push(ExportEntry {
classified_idx: idx,
name: None,
is_void: true,
});
continue;
}
CjsExportKind::SelfRef => {
export_entries.push(ExportEntry {
classified_idx: idx,
name: None,
is_void: true,
});
continue;
}
};
export_entries.push(ExportEntry {
classified_idx: idx,
name,
is_void,
});
}
}
// For each unique name, find the last non-void index
let mut last_real: HashMap<Option<Atom>, usize> = HashMap::new();
for e in &export_entries {
if !e.is_void {
last_real.insert(e.name.clone(), e.classified_idx);
}
}
// Build drop set
let mut drop_set: std::collections::HashSet<usize> = std::collections::HashSet::new();
for e in &export_entries {
if e.is_void {
drop_set.insert(e.classified_idx);
} else if let Some(&last_idx) = last_real.get(&e.name) {
if e.classified_idx != last_idx {
drop_set.insert(e.classified_idx);
}
}
}
// A require binding used exclusively by kept live re-export getters no
// longer needs a local import. The export-from declaration itself is
// the module evaluation dependency. If any getter is dropped or the
// binding has another use, retain the ordinary import.
let mut kept_reexport_counts: HashMap<BindingId, usize> = HashMap::new();
for (idx, item) in classified.iter().enumerate() {
if drop_set.contains(&idx) {
continue;
}
if let Classified::CjsExport {
kind: CjsExportKind::ReExport { binding, .. },
..
} = item
{
*kept_reexport_counts.entry(binding.clone()).or_default() += 1;
}
}
let consumed_reexport_bindings: HashSet<BindingId> = kept_reexport_counts
.into_iter()
.filter_map(|(binding, count)| {
(binding_uses.use_count(&binding) == count).then_some(binding)
})
.collect();
// Phase 3: collect imports — build source_map keyed by String
let mut source_order: Vec<String> = Vec::new();
let mut source_map: HashMap<String, SourceEntry> = HashMap::new();
// First pass: mark which sources have CJS requires
let mut cjs_sources: std::collections::HashSet<String> = std::collections::HashSet::new();
for c in classified.iter() {
let src = match c {
Classified::CjsRequire(CjsRequireKind::Bare { source }) => source.clone(),
Classified::CjsRequire(CjsRequireKind::Default { local, source }) => {
if consumed_reexport_bindings.contains(&(local.sym.clone(), local.ctxt)) {
continue;
}
source.clone()
}
Classified::CjsRequire(CjsRequireKind::Named { source, .. }) => source.clone(),
Classified::CjsRequire(CjsRequireKind::DefaultProp { source, .. }) => {
source.clone()
}
Classified::CjsRequire(CjsRequireKind::NamedProp { source, .. }) => source.clone(),
_ => continue,
};
cjs_sources.insert(src);
}
for c in classified.iter() {
match c {
Classified::ExistingImport(import) => {
let src = wtf8_to_string(&import.src.value);
if cjs_sources.contains(&src) {
// Source has CJS requires → absorb non-namespace specifiers into source_map
let has_ns = import
.specifiers
.iter()
.any(|s| matches!(s, ImportSpecifier::Namespace(_)));
let has_non_ns = import
.specifiers
.iter()
.any(|s| !matches!(s, ImportSpecifier::Namespace(_)));
if has_non_ns {
let entry =
get_or_insert(&mut source_order, &mut source_map, src.clone());
entry.has_cjs = true;
for spec in &import.specifiers {
match spec {
ImportSpecifier::Default(d) => {
entry.add_default(d.local.clone())
}
ImportSpecifier::Named(n) => {
let imported: Atom = match &n.imported {
Some(ModuleExportName::Ident(i)) => i.sym.clone(),
Some(ModuleExportName::Str(_)) => n.local.sym.clone(),
None => n.local.sym.clone(),
};
entry.add_named(imported, n.local.clone());
}
ImportSpecifier::Namespace(_) => {}
}
}
} else if !has_ns && import.specifiers.is_empty() {
let entry =
get_or_insert(&mut source_order, &mut source_map, src.clone());
entry.has_cjs = true;
entry.set_bare();
}
// Namespace specifiers in a source-with-CJS: keep as original pass-through
if has_ns {
// Build a namespace-only import to pass through
let ns_specs: Vec<ImportSpecifier> = import
.specifiers
.iter()
.filter(|s| matches!(s, ImportSpecifier::Namespace(_)))
.cloned()
.collect();
if !ns_specs.is_empty() {
let ns_import = ImportDecl {
specifiers: ns_specs,
..import.clone()
};
// Use a unique key to preserve ordering in source_order
let ns_key = format!("__ns__:{}", src);
let entry =
get_or_insert(&mut source_order, &mut source_map, ns_key);
entry.original_imports.push(ns_import);
}
}
} else {
// No CJS for this source — pass through entire import unchanged
let entry = get_or_insert(&mut source_order, &mut source_map, src);
entry.original_imports.push(import.clone());
}
}
Classified::CjsRequire(kind) => match kind {
CjsRequireKind::Bare { source } => {
let entry =
get_or_insert(&mut source_order, &mut source_map, source.clone());
entry.has_cjs = true;
entry.set_bare();
}
CjsRequireKind::Default { local, source } => {
if consumed_reexport_bindings.contains(&(local.sym.clone(), local.ctxt)) {
continue;
}
let entry =
get_or_insert(&mut source_order, &mut source_map, source.clone());
entry.has_cjs = true;
entry.add_default(local.clone());
}
CjsRequireKind::Named { specifiers, source } => {
let entry =
get_or_insert(&mut source_order, &mut source_map, source.clone());
entry.has_cjs = true;
for (imported, local) in specifiers {
entry.add_named(imported.clone(), local.clone());
}
}
CjsRequireKind::DefaultProp { local, source } => {
let entry =
get_or_insert(&mut source_order, &mut source_map, source.clone());
entry.has_cjs = true;
entry.add_default(local.clone());
}
CjsRequireKind::NamedProp {
prop,
local,
source,
} => {
let entry =
get_or_insert(&mut source_order, &mut source_map, source.clone());
entry.has_cjs = true;
entry.add_named(prop.clone(), local.clone());
}
},
_ => {}
}
}
// Build import declarations
let mut import_decls: Vec<ModuleItem> = Vec::new();
// Process sources in first-seen order
for src in &source_order {
let entry = &source_map[src];
if entry.has_cjs {
// Merge CJS requires with any existing imports for this source
build_import_decls(src, entry, &mut import_decls);
} else {
// No CJS requires — pass through original imports unchanged
for orig in &entry.original_imports {
import_decls.push(ModuleItem::ModuleDecl(ModuleDecl::Import(orig.clone())));
}
}
}
// Collect local names that conflict with export names. Export names
// take priority (they're meaningful from the original source), so we
// rename the conflicting locals to free up the name for the export.
let mut local_names: HashSet<Atom> = HashSet::new();
for item in &import_decls {
if let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item {
for spec in &import.specifiers {
match spec {
ImportSpecifier::Named(n) => {
local_names.insert(n.local.sym.clone());
}
ImportSpecifier::Default(d) => {
local_names.insert(d.local.sym.clone());
}
ImportSpecifier::Namespace(ns) => {
local_names.insert(ns.local.sym.clone());
}
}
}
}
}
for c in &classified {
if let Classified::Keep(ModuleItem::Stmt(Stmt::Decl(decl))) = c {
collect_decl_names(decl, &mut local_names);
}
}
// Find export names that clash with existing locals.
// Export names take priority (meaningful from original source), so
// rename the conflicting locals before building export items.
let mut export_names: HashSet<Atom> = HashSet::new();
for (idx, c) in classified.iter().enumerate() {
if drop_set.contains(&idx) {
continue;
}
if let Classified::CjsExport {
kind:
CjsExportKind::Named {
name,
expr,
is_void: false,
},
..
} = c
{
let is_ident = matches!(expr.as_ref(), Expr::Ident(_));
if !is_ident && local_names.contains(name) {
export_names.insert(name.clone());
}
}
}
// Rename conflicting locals before building exports. The export
// expression can reference a conflicting module-level local, so apply
// binding-id renames to both kept items and export expressions.
if !export_names.is_empty() {
let mut used_names = all_declared_names.clone();
used_names.extend(export_names.iter().cloned());
let mut renames = Vec::new();
collect_conflicting_import_renames(
&import_decls,
&export_names,
&mut used_names,
&mut renames,
);
for c in &classified {
if let Classified::Keep(ModuleItem::Stmt(Stmt::Decl(decl))) = c {
collect_conflicting_decl_renames(
decl,
&export_names,
&mut used_names,
&mut renames,
);
}
}
if !renames.is_empty() {
for item in &mut import_decls {
rename_bindings(item, &renames);
}
for c in classified.iter_mut() {
match c {
Classified::Keep(item) => rename_bindings(item, &renames),
Classified::CjsExport { kind, .. } => rename_export_kind(kind, &renames),
_ => {}
}
}
}
}
// Build final module body
let mut new_body: Vec<ModuleItem> = import_decls;
for (idx, c) in classified.into_iter().enumerate() {
match c {
Classified::ExistingImport(_) => {} // skip, already absorbed
Classified::CjsRequire(_) => {} // skip, replaced by import
Classified::CjsExport { span, kind } => {
if drop_set.contains(&idx) {
new_body.extend(build_dropped_export_side_effect_items(span, kind));
} else {
new_body.extend(build_export_items(span, kind));
}
}
Classified::Keep(item) => {
new_body.push(item);
}
}
}
merge_decl_and_named_export(&mut new_body);
inline_adjacent_default_export_aliases(&mut new_body);
module.body = new_body;
}
}
/// Merge adjacent `var/let/const X = expr;` + `export { X };` into `export var/let/const X = expr;`.
/// Preserves the original declaration kind.
/// This pattern arises when `split_compound_exports` splits `var X = exports.X = expr`.
fn merge_decl_and_named_export(body: &mut Vec<ModuleItem>) {
let mut i = 0;
while i + 1 < body.len() {
// Check if body[i] is a single-binding var decl and body[i+1] is `export { name }`
let merged = 'merge: {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = &body[i] else {
break 'merge false;
};
if var_decl.decls.len() != 1 {
break 'merge false;
}
let Pat::Ident(binding) = &var_decl.decls[0].name else {
break 'merge false;
};
if var_decl.decls[0].init.is_none() {
break 'merge false;
}
let ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(named)) = &body[i + 1] else {
break 'merge false;
};
if named.src.is_some() || named.specifiers.len() != 1 {
break 'merge false;
}
let ExportSpecifier::Named(spec) = &named.specifiers[0] else {
break 'merge false;
};
if spec.exported.is_some() {
break 'merge false;
}
let ModuleExportName::Ident(export_id) = &spec.orig else {
break 'merge false;
};
if export_id.sym != binding.id.sym || export_id.ctxt != binding.id.ctxt {
break 'merge false;
}
true
};
if merged {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = body.remove(i) else {
unreachable!();
};
let orig_span = var_decl.span;
let kind = var_decl.kind;
let decl = var_decl.decls.into_iter().next().unwrap();
body[i] = ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
span: orig_span,
decl: Decl::Var(Box::new(VarDecl {
span: orig_span,
ctxt: Default::default(),
kind,
declare: false,
decls: vec![decl],
})),
}));
}
i += 1;
}
}
fn inline_adjacent_default_export_aliases(body: &mut Vec<ModuleItem>) {
let mut index = 0;
while index + 1 < body.len() {
let Some((alias, init)) = default_export_alias_decl(&body[index]) else {
index += 1;
continue;
};
let Some(export_ident) = default_export_ident(&body[index + 1]) else {
index += 1;
continue;
};
if !same_ident(&alias, export_ident) {
index += 1;
continue;
}
let alias_key = (alias.sym.clone(), alias.ctxt);
if count_binding_refs(body, &alias_key, Some(index)) != 1 {
index += 1;
continue;
}
let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export)) = &mut body[index + 1]
else {
index += 1;
continue;
};
export.expr = init;
body.remove(index);
}
}
fn default_export_alias_decl(item: &ModuleItem) -> Option<(Ident, Box<Expr>)> {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
return None;
};
if var.decls.len() != 1 {
return None;
}
let decl = &var.decls[0];
let Pat::Ident(binding) = &decl.name else {
return None;
};
let Some(init) = &decl.init else {
return None;
};
if !matches!(init.as_ref(), Expr::Ident(_)) {
return None;
}
Some((binding.id.clone(), init.clone()))
}
fn default_export_ident(item: &ModuleItem) -> Option<&Ident> {
let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export)) = item else {
return None;
};
let Expr::Ident(id) = export.expr.as_ref() else {
return None;
};
Some(id)
}
fn count_binding_refs(
body: &[ModuleItem],
key: &(Atom, SyntaxContext),
skip_index: Option<usize>,
) -> usize {
let mut counter = BindingRefCounter { key, count: 0 };
for (index, item) in body.iter().enumerate() {
if skip_index == Some(index) {
continue;
}
item.visit_with(&mut counter);
}
counter.count
}
struct BindingRefCounter<'a> {
key: &'a (Atom, SyntaxContext),
count: usize,
}
impl Visit for BindingRefCounter<'_> {
fn visit_ident(&mut self, id: &Ident) {
if id.sym == self.key.0 && id.ctxt == self.key.1 {
self.count += 1;
}
}
}
fn get_or_insert<'a>(
order: &mut Vec<String>,
map: &'a mut HashMap<String, SourceEntry>,
src: String,
) -> &'a mut SourceEntry {
match map.entry(src.clone()) {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => {
order.push(src);
entry.insert(SourceEntry::default())
}
}
}
fn rewrite_webpack_export_getters(module: &mut Module, unresolved_mark: Mark) {
expose_unused_iife_webpack_export_getters(module, unresolved_mark);
let mut converted_getter_map = false;
let mut new_body = Vec::with_capacity(module.body.len());
// Webpack5 getter maps appear at the top of the module, before the
// declarations they reference. Deferring all converted exports to the
// end of the body (a) avoids TDZ violations for `export default ident`
// and (b) places `exports.X = X` adjacent to its `const X = ...`
// declaration so merge_decl_and_named_export can fold them into
// `export const X = ...`.
let mut deferred_named: Vec<ModuleItem> = Vec::new();
let mut deferred_default: Vec<ModuleItem> = Vec::new();
for item in std::mem::take(&mut module.body) {
let item_span = module_item_span(&item);
if let Some(exports) = extract_direct_webpack_export_getters(&item, unresolved_mark) {
for (name, expr) in exports {
if name.as_ref() == "default" {
if let Expr::Ident(ident) = *expr {
// Webpack5 getter `() => ident` is a live accessor.
// Emit `export { ident as default }` directly — this
// preserves live-binding semantics and avoids TDZ,
// bypassing CJS classification (which would snapshot).
deferred_default.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
NamedExport {
span: item_span,
specifiers: vec![ExportSpecifier::Named(ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(ident),
exported: Some(ModuleExportName::Ident(
IdentName::new("default".into(), DUMMY_SP).into(),
)),
is_type_only: false,
})],
src: None,
type_only: false,
with: None,
},
)));
} else {
deferred_default.push(make_exports_assign_expr_item(
item_span,
(name, expr),
unresolved_mark,
));
}
} else {
deferred_named.push(make_exports_assign_expr_item(
item_span,
(name, expr),
unresolved_mark,
));
}
}
continue;
}
if let Some(exports) = extract_webpack_export_getter_iife(&item, unresolved_mark) {
converted_getter_map = true;
// IIFE getters already reject `default` entries, so no TDZ risk.
// Keep them in-place to preserve adjacency with their declarations
// for merge_decl_and_named_export.
new_body.extend(
exports.into_iter().map(|export| {
make_exports_assign_expr_item(item_span, export, unresolved_mark)
}),
);
continue;
}
if converted_getter_map && is_exports_default_compat_block(&item, unresolved_mark) {
continue;
}
new_body.push(item);
}
// Named exports first (adjacent to their declarations for merging),
// then default exports last (after all declarations to avoid TDZ).
new_body.extend(deferred_named);
new_body.extend(deferred_default);
module.body = new_body;
}
fn expose_unused_iife_webpack_export_getters(module: &mut Module, unresolved_mark: Mark) {
if module.body.len() != 1 {
return;
}
let Some(expanded) =
extract_unused_iife_webpack_export_getter_body(&module.body[0], unresolved_mark)
else {
return;
};
module.body = expanded;
}
fn extract_unused_iife_webpack_export_getter_body(
item: &ModuleItem,
unresolved_mark: Mark,
) -> Option<Vec<ModuleItem>> {
let ModuleItem::Stmt(Stmt::Expr(expr_stmt)) = item else {
return None;
};
let Expr::Call(call) = expr_stmt.expr.as_ref() else {
return None;
};
if call.args.iter().any(|arg| arg.spread.is_some()) {
return None;
}
let Callee::Expr(callee_expr) = &call.callee else {
return None;
};
let Expr::Arrow(arrow) = strip_parens(callee_expr.as_ref()) else {
return None;
};
let BlockStmtOrExpr::BlockStmt(block) = arrow.body.as_ref() else {
return None;
};
if block_has_top_level_return(block) || block_contains_arguments_ident(block) {
return None;
}
if !block_contains_direct_webpack_export_getter(block, unresolved_mark) {
return None;
}
if arrow_params_used_in_block(arrow, block) {
return None;
}
let outer_span = expr_stmt.span;
let mut items = Vec::with_capacity(call.args.len() + block.stmts.len());
items.extend(call.args.iter().map(|arg| {
ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span: outer_span,
expr: arg.expr.clone(),
}))
}));
items.extend(block.stmts.iter().cloned().map(ModuleItem::Stmt));
Some(items)
}
fn block_contains_direct_webpack_export_getter(block: &BlockStmt, unresolved_mark: Mark) -> bool {
block.stmts.iter().any(|stmt| {
extract_direct_webpack_export_getters(&ModuleItem::Stmt(stmt.clone()), unresolved_mark)
.is_some()
})
}
fn block_has_top_level_return(block: &BlockStmt) -> bool {
block
.stmts
.iter()
.any(|stmt| matches!(stmt, Stmt::Return(_)))
}
fn arrow_params_used_in_block(arrow: &ArrowExpr, block: &BlockStmt) -> bool {
let params: Vec<Ident> = arrow
.params
.iter()
.filter_map(|param| match param {
Pat::Ident(binding) => Some(binding.id.clone()),
_ => None,
})
.collect();
if params.len() != arrow.params.len() {
return true;
}
if params.is_empty() {
return false;
}
let mut finder = IdentUseFinder {
targets: ¶ms,
found: false,
};
block.visit_with(&mut finder);
finder.found
}
struct IdentUseFinder<'a> {
targets: &'a [Ident],
found: bool,
}
impl Visit for IdentUseFinder<'_> {
fn visit_ident(&mut self, ident: &Ident) {
if self.targets.iter().any(|target| same_ident(ident, target)) {
self.found = true;
}
}
}
fn block_contains_arguments_ident(block: &BlockStmt) -> bool {
let mut finder = ArgumentsIdentFinder { found: false };
block.visit_with(&mut finder);
finder.found
}
struct ArgumentsIdentFinder {
found: bool,
}
impl Visit for ArgumentsIdentFinder {
fn visit_ident(&mut self, ident: &Ident) {
if ident.sym == "arguments" {
self.found = true;
}
}
}
fn extract_direct_webpack_export_getters(
item: &ModuleItem,
unresolved_mark: Mark,
) -> Option<Vec<(Atom, Box<Expr>)>> {
let ModuleItem::Stmt(Stmt::Expr(expr_stmt)) = item else {
return None;
};
let Expr::Call(call) = expr_stmt.expr.as_ref() else {
return None;
};
let Callee::Expr(callee_expr) = &call.callee else {
return None;
};
if !is_unresolved_member_expr(callee_expr.as_ref(), "require", "d", unresolved_mark) {
return None;
}
if call.args.is_empty() {
return None;
}
if !matches!(call.args[0].expr.as_ref(), Expr::Ident(id) if is_unresolved_ident(id, "exports", unresolved_mark))
{
return None;
}
if call.args.len() == 2 {
let Expr::Object(getter_map) = call.args[1].expr.as_ref() else {
return None;
};
let exports = extract_export_getter_map(getter_map)?;
if exports.is_empty() {
return None;
}
return Some(exports);
}
if call.args.len() == 3 {
let Expr::Lit(Lit::Str(name)) = call.args[1].expr.as_ref() else {
return None;
};
let export_name = name.value.as_str()?;
if !is_valid_js_ident(export_name) {
return None;
}
let expr = extract_getter_expr_return_expr(call.args[2].expr.as_ref())?;
return Some(vec![(export_name.into(), expr)]);
}
None
}
fn extract_webpack_export_getter_iife(
item: &ModuleItem,
unresolved_mark: Mark,
) -> Option<Vec<(Atom, Box<Expr>)>> {
let ModuleItem::Stmt(Stmt::Expr(expr_stmt)) = item else {
return None;
};
let Expr::Call(call) = expr_stmt.expr.as_ref() else {
return None;
};
if call.args.len() != 2 {
return None;
}
let Callee::Expr(callee_expr) = &call.callee else {
return None;
};
let Expr::Arrow(arrow) = strip_parens(callee_expr.as_ref()) else {
return None;
};
let (target_param, map_param) = extract_two_ident_params(arrow)?;
if !is_webpack_export_getter_loop(arrow, &target_param, &map_param) {
return None;
}
if !matches!(call.args[0].expr.as_ref(), Expr::Ident(id) if is_unresolved_ident(id, "exports", unresolved_mark))
{
return None;
}
let Expr::Object(getter_map) = call.args[1].expr.as_ref() else {
return None;
};
let exports = extract_export_getter_map(getter_map)?;
if exports.is_empty() || exports.iter().any(|(name, _)| name.as_ref() == "default") {
return None;
}
Some(exports)
}
fn extract_two_ident_params(arrow: &ArrowExpr) -> Option<(Ident, Ident)> {
if arrow.params.len() != 2 {
return None;
}
let Pat::Ident(target) = &arrow.params[0] else {
return None;
};
let Pat::Ident(map) = &arrow.params[1] else {
return None;
};
Some((target.id.clone(), map.id.clone()))
}
fn is_webpack_export_getter_loop(
arrow: &ArrowExpr,
target_param: &Ident,
map_param: &Ident,
) -> bool {
let BlockStmtOrExpr::BlockStmt(block) = arrow.body.as_ref() else {
return false;
};
if block.stmts.len() != 1 {
return false;
}
let Stmt::ForIn(ForInStmt {
left, right, body, ..
}) = &block.stmts[0]
else {
return false;
};
if !matches!(right.as_ref(), Expr::Ident(id) if same_ident(id, map_param)) {
return false;
}
let Some(loop_ident) = extract_for_in_ident(left) else {
return false;
};
let Stmt::Block(body_block) = body.as_ref() else {
return false;
};
if body_block.stmts.len() != 1 {
return false;
}
let Stmt::Expr(ExprStmt { expr, .. }) = &body_block.stmts[0] else {
return false;
};
let Expr::Call(call) = expr.as_ref() else {
return false;
};
is_object_define_property_call(call, target_param, &loop_ident, map_param)
}
fn extract_for_in_ident(left: &ForHead) -> Option<Ident> {
match left {
ForHead::VarDecl(var) => {
if var.decls.len() != 1 {
return None;
}
let decl = &var.decls[0];
if decl.init.is_some() {
return None;
}
let Pat::Ident(binding) = &decl.name else {
return None;
};
Some(binding.id.clone())
}
ForHead::Pat(pat) => {
let Pat::Ident(binding) = pat.as_ref() else {
return None;
};
Some(binding.id.clone())
}
_ => None,
}
}
fn is_object_define_property_call(
call: &CallExpr,
target_param: &Ident,
loop_ident: &Ident,
map_param: &Ident,
) -> bool {
let Callee::Expr(callee_expr) = &call.callee else {
return false;
};
if !is_member_expr(callee_expr.as_ref(), "Object", "defineProperty") || call.args.len() != 3 {
return false;
}
if !matches!(call.args[0].expr.as_ref(), Expr::Ident(id) if same_ident(id, target_param)) {
return false;
}
if !matches!(call.args[1].expr.as_ref(), Expr::Ident(id) if same_ident(id, loop_ident)) {
return false;
}
is_export_getter_descriptor(call.args[2].expr.as_ref(), map_param, loop_ident)
}
fn is_export_getter_descriptor(expr: &Expr, map_param: &Ident, loop_ident: &Ident) -> bool {
let Expr::Object(object) = expr else {
return false;
};
let mut has_enumerable_true = false;
let mut has_getter_lookup = false;
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return false;
};
let Prop::KeyValue(entry) = prop.as_ref() else {
return false;
};
match prop_name_as_atom(&entry.key).as_deref() {
Some("enumerable") => {
has_enumerable_true =
matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(b)) if b.value);
}
Some("get") => {
has_getter_lookup = is_map_lookup(entry.value.as_ref(), map_param, loop_ident);
}
_ => return false,
}
}
has_enumerable_true && has_getter_lookup
}
fn extract_export_getter_map(
object: &swc_core::ecma::ast::ObjectLit,
) -> Option<Vec<(Atom, Box<Expr>)>> {
let mut exports = Vec::with_capacity(object.props.len());
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return None;
};
let (name, expr) = match prop.as_ref() {
Prop::Method(method) => {
let name = prop_name_as_atom(&method.key)?;
if !method.function.params.is_empty()
|| method.function.is_async
|| method.function.is_generator
{
return None;
}
let expr = extract_single_return_expr(method.function.body.as_ref()?)?;
(name, expr)
}
Prop::KeyValue(entry) => {
let name = prop_name_as_atom(&entry.key)?;
let expr = extract_getter_expr_return_expr(entry.value.as_ref())?;
(name, expr)
}
_ => return None,
};
exports.push((name, expr));
}
Some(exports)
}
fn extract_getter_expr_return_expr(expr: &Expr) -> Option<Box<Expr>> {
match expr {
Expr::Fn(fn_expr) => {
if fn_expr.ident.is_some()
|| !fn_expr.function.params.is_empty()
|| fn_expr.function.is_async
|| fn_expr.function.is_generator
{
return None;
}
extract_single_return_expr(fn_expr.function.body.as_ref()?)
}
Expr::Arrow(arrow) => {
if !arrow.params.is_empty() || arrow.is_async || arrow.is_generator {
return None;
}
match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => extract_single_return_expr(block),
BlockStmtOrExpr::Expr(expr) => Some(expr.clone()),
}
}
_ => None,
}
}
fn extract_single_return_expr(block: &BlockStmt) -> Option<Box<Expr>> {
if block.stmts.len() != 1 {
return None;
}
let Stmt::Return(ReturnStmt { arg: Some(arg), .. }) = &block.stmts[0] else {
return None;
};
Some(arg.clone())
}
fn make_exports_assign_expr_item(
span: Span,
(name, expr): (Atom, Box<Expr>),
unresolved_mark: Mark,
) -> ModuleItem {
ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span,
expr: Box::new(Expr::Assign(AssignExpr {
span: DUMMY_SP,
op: AssignOp::Assign,
left: AssignTarget::Simple(SimpleAssignTarget::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(Expr::Ident(make_unresolved_ident(
"exports".into(),
unresolved_mark,
))),
prop: MemberProp::Ident(IdentName::new(name, DUMMY_SP)),
})),
right: expr,
})),
}))
}
fn is_exports_default_compat_block(item: &ModuleItem, unresolved_mark: Mark) -> bool {
let ModuleItem::Stmt(Stmt::If(if_stmt)) = item else {
return false;
};
if if_stmt.alt.is_some() {
return false;
}
if !is_exports_default_compat_test(if_stmt.test.as_ref(), unresolved_mark) {
return false;
}
let Stmt::Block(block) = if_stmt.cons.as_ref() else {
return false;
};
if block.stmts.len() != 3 {
return false;
}
is_define_esmodule_on_exports_default(&block.stmts[0], unresolved_mark)
&& is_object_assign_exports_default_exports(&block.stmts[1], unresolved_mark)
&& is_module_exports_default_reassignment(&block.stmts[2], unresolved_mark)
}
fn is_exports_default_compat_test(expr: &Expr, unresolved_mark: Mark) -> bool {
let Expr::Bin(bin) = strip_parens(expr) else {
return false;
};
bin.op == BinaryOp::LogicalAnd
&& is_exports_default_type_guard(bin.left.as_ref(), unresolved_mark)
&& is_exports_default_esmodule_undefined(bin.right.as_ref(), unresolved_mark)
}
fn is_exports_default_type_guard(expr: &Expr, unresolved_mark: Mark) -> bool {
let Expr::Bin(bin) = strip_parens(expr) else {
return false;
};
if bin.op != BinaryOp::LogicalOr {
return false;
}
let Expr::Bin(object_and_not_null) = strip_parens(bin.right.as_ref()) else {
return false;
};
is_typeof_exports_default_eq(bin.left.as_ref(), "function", unresolved_mark)
&& object_and_not_null.op == BinaryOp::LogicalAnd
&& is_typeof_exports_default_eq(
object_and_not_null.left.as_ref(),
"object",
unresolved_mark,
)
&& is_exports_default_not_null(object_and_not_null.right.as_ref(), unresolved_mark)
}
fn is_typeof_exports_default_eq(expr: &Expr, expected: &str, unresolved_mark: Mark) -> bool {
let Expr::Bin(bin) = strip_parens(expr) else {
return false;
};
if bin.op != BinaryOp::EqEqEq {
return false;
}
matches!(strip_parens(bin.left.as_ref()), Expr::Unary(unary)
if unary.op == UnaryOp::TypeOf && is_exports_default_expr(unary.arg.as_ref(), unresolved_mark))
&& matches!(strip_parens(bin.right.as_ref()), Expr::Lit(Lit::Str(s))
if s.value.as_str() == Some(expected))
}
fn is_exports_default_not_null(expr: &Expr, unresolved_mark: Mark) -> bool {
let Expr::Bin(bin) = strip_parens(expr) else {
return false;
};
bin.op == BinaryOp::NotEqEq
&& is_exports_default_expr(bin.left.as_ref(), unresolved_mark)
&& matches!(strip_parens(bin.right.as_ref()), Expr::Lit(Lit::Null(_)))
}
fn is_exports_default_esmodule_undefined(expr: &Expr, unresolved_mark: Mark) -> bool {
let Expr::Bin(bin) = strip_parens(expr) else {
return false;
};
bin.op == BinaryOp::EqEqEq
&& is_exports_default_esmodule_expr(bin.left.as_ref(), unresolved_mark)
&& matches!(strip_parens(bin.right.as_ref()), Expr::Ident(id) if is_undefined_ident(id, unresolved_mark))
}
fn is_exports_default_esmodule_expr(expr: &Expr, unresolved_mark: Mark) -> bool {
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
matches!(&member.prop, MemberProp::Ident(prop) if prop.sym == "__esModule")
&& is_exports_default_expr(member.obj.as_ref(), unresolved_mark)
}
fn is_define_esmodule_on_exports_default(stmt: &Stmt, unresolved_mark: Mark) -> bool {
let Some(call) = expr_stmt_call(stmt) else {
return false;
};
let Callee::Expr(callee) = &call.callee else {
return false;
};
if !is_unresolved_member_expr(callee.as_ref(), "Object", "defineProperty", unresolved_mark)
|| call.args.len() != 3
{
return false;
}
if !is_exports_default_expr(call.args[0].expr.as_ref(), unresolved_mark) {
return false;
}
if !matches!(call.args[1].expr.as_ref(), Expr::Lit(Lit::Str(s)) if s.value.as_str() == Some("__esModule"))
{
return false;
}
let Expr::Object(obj) = call.args[2].expr.as_ref() else {
return false;
};
obj.props.iter().any(|prop| {
let PropOrSpread::Prop(prop) = prop else {
return false;
};
let Prop::KeyValue(entry) = prop.as_ref() else {
return false;
};
prop_name_as_atom(&entry.key).as_deref() == Some("value")
&& matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(b)) if b.value)
})
}
fn is_object_assign_exports_default_exports(stmt: &Stmt, unresolved_mark: Mark) -> bool {
let Some(call) = expr_stmt_call(stmt) else {
return false;
};
let Callee::Expr(callee) = &call.callee else {
return false;
};
is_unresolved_member_expr(callee.as_ref(), "Object", "assign", unresolved_mark)
&& call.args.len() == 2
&& is_exports_default_expr(call.args[0].expr.as_ref(), unresolved_mark)
&& matches!(call.args[1].expr.as_ref(), Expr::Ident(id) if is_unresolved_ident(id, "exports", unresolved_mark))
}
fn is_module_exports_default_reassignment(stmt: &Stmt, unresolved_mark: Mark) -> bool {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return false;
};
let Expr::Assign(assign) = expr.as_ref() else {
return false;
};
if assign.op != AssignOp::Assign
|| !is_exports_default_expr(assign.right.as_ref(), unresolved_mark)
{
return false;
}
let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left else {
return false;
};
is_module_exports_member(member, unresolved_mark)
}
fn expr_stmt_call(stmt: &Stmt) -> Option<&CallExpr> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Call(call) = expr.as_ref() else {
return None;
};
Some(call)
}
fn is_exports_default_expr(expr: &Expr, unresolved_mark: Mark) -> bool {
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
matches!(member.obj.as_ref(), Expr::Ident(id) if is_unresolved_ident(id, "exports", unresolved_mark))
&& matches!(&member.prop, MemberProp::Ident(prop) if prop.sym == "default")
}
fn is_module_exports_member(member: &MemberExpr, unresolved_mark: Mark) -> bool {
matches!(member.obj.as_ref(), Expr::Ident(id) if is_unresolved_ident(id, "module", unresolved_mark))
&& matches!(&member.prop, MemberProp::Ident(prop) if prop.sym == "exports")
}
fn is_unresolved_member_expr(
expr: &Expr,
object: &str,
property: &str,
unresolved_mark: Mark,
) -> bool {
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
matches!(member.obj.as_ref(), Expr::Ident(id) if is_unresolved_ident(id, object, unresolved_mark))
&& matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == property)
}
fn is_member_expr(expr: &Expr, object: &str, property: &str) -> bool {
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
matches!(member.obj.as_ref(), Expr::Ident(id) if id.sym.as_ref() == object)
&& matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == property)
}
fn is_map_lookup(expr: &Expr, map_param: &Ident, loop_ident: &Ident) -> bool {
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
if !matches!(member.obj.as_ref(), Expr::Ident(id) if same_ident(id, map_param)) {
return false;
}
let MemberProp::Computed(computed) = &member.prop else {
return false;
};
matches!(computed.expr.as_ref(), Expr::Ident(id) if same_ident(id, loop_ident))
}
fn prop_name_as_atom(name: &PropName) -> Option<Atom> {
match name {
PropName::Ident(ident) => Some(ident.sym.clone()),
PropName::Str(str) => {
let value = str.value.as_str()?;
if is_valid_js_ident(value) {
Some(value.into())
} else {
None
}
}
_ => None,
}
}
fn build_import_decls(src: &str, entry: &SourceEntry, out: &mut Vec<ModuleItem>) {
// Case: bare-only import (no bindings at all)
if entry.bare
&& entry.first_default.is_none()
&& entry.named.is_empty()
&& entry.extra_defaults.is_empty()
{
out.push(ModuleItem::ModuleDecl(ModuleDecl::Import(
make_import_decl(src, vec![]),
)));
return;
}
// Primary import: first_default + all named
let mut specifiers: Vec<ImportSpecifier> = Vec::new();
if let Some(ref def) = entry.first_default {
specifiers.push(ImportSpecifier::Default(ImportDefaultSpecifier {
span: DUMMY_SP,
local: def.clone(),
}));
}
for (imported, local) in &entry.named {
if *imported == local.sym {
specifiers.push(ImportSpecifier::Named(ImportNamedSpecifier {
span: DUMMY_SP,
local: local.clone(),
imported: None,
is_type_only: false,
}));
} else {
specifiers.push(ImportSpecifier::Named(ImportNamedSpecifier {
span: DUMMY_SP,
local: local.clone(),
imported: Some(ModuleExportName::Ident(make_ident(imported.clone()))),
is_type_only: false,
}));
}
}
if !specifiers.is_empty() {
out.push(ModuleItem::ModuleDecl(ModuleDecl::Import(
make_import_decl(src, specifiers),
)));
}
// Extra defaults → separate import statements
for extra in &entry.extra_defaults {
out.push(ModuleItem::ModuleDecl(ModuleDecl::Import(
make_import_decl(
src,
vec![ImportSpecifier::Default(ImportDefaultSpecifier {
span: DUMMY_SP,
local: extra.clone(),
})],
),
)));
}
}
fn make_import_decl(src: &str, specifiers: Vec<ImportSpecifier>) -> ImportDecl {
ImportDecl {
span: DUMMY_SP,
specifiers,
src: Box::new(make_str(src)),
type_only: false,
with: None,
phase: Default::default(),
}
}
fn build_export_items(span: Span, kind: CjsExportKind) -> Vec<ModuleItem> {
match kind {
CjsExportKind::EsModuleFlag => vec![],
CjsExportKind::ModuleExportsDefault { expr } => vec![ModuleItem::ModuleDecl(
ModuleDecl::ExportDefaultExpr(ExportDefaultExpr { span, expr }),
)],
CjsExportKind::NamedDefault { expr } => vec![ModuleItem::ModuleDecl(
ModuleDecl::ExportDefaultExpr(ExportDefaultExpr { span, expr }),
)],
CjsExportKind::ReExport {
name,
imported,
source,
..
} => vec![ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
NamedExport {
span,
specifiers: vec![ExportSpecifier::Named(ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(
IdentName::new(imported.clone(), DUMMY_SP).into(),
),
exported: (imported != name)
.then(|| ModuleExportName::Ident(IdentName::new(name, DUMMY_SP).into())),
is_type_only: false,
})],
src: Some(Box::new(make_str(&source))),
type_only: false,
with: None,
},
))],
CjsExportKind::DefaultMirror => vec![],
CjsExportKind::Named {
name,
expr,
is_void: false,
} => {
if let Expr::Ident(id) = *expr {
if id.sym == name {
// export { foo }
vec![ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
NamedExport {
span,
specifiers: vec![ExportSpecifier::Named(ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(id),
exported: None,
is_type_only: false,
})],
src: None,
type_only: false,
with: None,
},
))]
} else {
// export { id as name }
vec![ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
NamedExport {
span,
specifiers: vec![ExportSpecifier::Named(ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(id),
exported: Some(ModuleExportName::Ident(make_ident(name))),
is_type_only: false,
})],
src: None,
type_only: false,
with: None,
},
))]
}
} else {
// export const name = expr
vec![ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
span,
decl: Decl::Var(Box::new(VarDecl {
span: DUMMY_SP,
ctxt: Default::default(),
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(BindingIdent {
id: make_ident(name),
type_ann: None,
}),
init: Some(expr),
definite: false,
}],
})),
}))]
}
}
CjsExportKind::Named { is_void: true, .. } => vec![], // should have been dropped
CjsExportKind::SelfRef => vec![],
}
}
fn build_dropped_export_side_effect_items(span: Span, kind: CjsExportKind) -> Vec<ModuleItem> {
let expr = match kind {
CjsExportKind::ModuleExportsDefault { expr }
| CjsExportKind::NamedDefault { expr }
| CjsExportKind::Named {
expr,
is_void: false,
..
} => expr,
CjsExportKind::EsModuleFlag
| CjsExportKind::ReExport { .. }
| CjsExportKind::Named { is_void: true, .. }
| CjsExportKind::DefaultMirror
| CjsExportKind::SelfRef => return vec![],
};
vec![ModuleItem::Stmt(Stmt::Expr(ExprStmt { span, expr }))]
}
// ============================================================
// Pre-pass: hoist require() calls out of complex expressions
// ============================================================
/// Hoists `require()` calls embedded inside sequence expressions and other
/// compound expressions into standalone statements so the classification
/// phase can convert them to ES imports.
///
/// Handles these patterns:
///
/// 1. `export default (i = require("./a.js"), require("./b.js"), expr)`
/// → `const i = require("./a.js"); require("./b.js"); export default expr;`
///
/// 2. `const a = (i = require("./a.js")) && i.__esModule ? i : { default: i }`
/// → `const i = require("./a.js"); const a = i;`
/// (inline conditional interop)
///
/// When every use of `a` is a read through `a.default` and `i` is private to
/// the helper expression, the pre-pass instead emits
/// `const a = require("./a.js").default` and rewrites those reads to `a`.
fn has_hoistable_require(items: &[ModuleItem], unresolved_mark: Mark) -> bool {
items.iter().any(|item| match item {
ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export_default)) => {
let expr = strip_parens(&export_default.expr);
if let Expr::Seq(seq) = expr {
if seq_has_require_call(&seq.exprs, unresolved_mark) {
return true;
}
}
if let Expr::Call(outer_call) = expr {
if let Callee::Expr(callee) = &outer_call.callee {
if let Expr::Call(inner_call) = strip_parens(callee) {
return is_require_call(inner_call, unresolved_mark).is_some();
}
}
}
false
}
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) if var_decl.decls.len() == 1 => {
var_decl.decls[0].init.as_ref().is_some_and(|init| {
try_extract_inline_conditional_interop(init, unresolved_mark).is_some()
})
}
_ => false,
})
}
fn hoist_embedded_requires(module: &mut Module, unresolved_mark: Mark) {
if !has_hoistable_require(&module.body, unresolved_mark) {
return;
}
let default_only_interop_bindings =
collect_default_only_inline_interop_bindings(module, unresolved_mark);
if !default_only_interop_bindings.is_empty() {
module.visit_mut_with(&mut DefaultInteropMemberRewriter {
bindings: &default_only_interop_bindings,
});
}
let mut new_body = Vec::with_capacity(module.body.len());
let mut used_names = collect_all_declared_names(module);
for item in std::mem::take(&mut module.body) {
match &item {
// Pattern 1: export default (seq_expr with require calls)
ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export_default)) => {
// Unwrap parens
let expr = strip_parens(&export_default.expr);
if let Expr::Seq(seq) = expr {
if seq_has_require_call(&seq.exprs, unresolved_mark) {
let (hoisted, final_expr) =
hoist_requires_from_seq(&seq.exprs, unresolved_mark, &mut used_names);
new_body.extend(hoisted);
new_body.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(
ExportDefaultExpr {
span: export_default.span,
expr: final_expr,
},
)));
continue;
}
}
// Pattern: export default require("...")(args) — require then call
// (Don't hoist plain `export default require("...")` — it's a valid
// re-export that namespace_decomposition can see through.)
if let Expr::Call(outer_call) = expr {
if let Callee::Expr(callee) = &outer_call.callee {
if let Expr::Call(inner_call) = strip_parens(callee) {
if is_require_call(inner_call, unresolved_mark).is_some() {
let local = make_ident(fresh_prefixed_name(
&Atom::from("default"),
&mut used_names,
));
new_body.push(make_require_var_item(
local.clone(),
Box::new(Expr::Call(inner_call.clone())),
));
let new_call = CallExpr {
callee: Expr::Ident(local).as_callee(),
args: outer_call.args.clone(),
span: outer_call.span,
ctxt: outer_call.ctxt,
type_args: outer_call.type_args.clone(),
};
new_body.push(ModuleItem::ModuleDecl(
ModuleDecl::ExportDefaultExpr(ExportDefaultExpr {
span: export_default.span,
expr: Box::new(Expr::Call(new_call)),
}),
));
continue;
}
}
}
}
new_body.push(item);
}
// Pattern 2: const a = (i = require("./a.js")) && i.__esModule ? i : { default: i }
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) if var_decl.decls.len() == 1 => {
let decl = &var_decl.decls[0];
if let Some(init) = &decl.init {
if let Some((require_local, source_expr)) =
try_extract_inline_conditional_interop(init, unresolved_mark)
{
if let Pat::Ident(wrapper) = &decl.name {
if default_only_interop_bindings.contains(&binding_id(&wrapper.id)) {
let require_default = Box::new(Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: source_expr,
prop: MemberProp::Ident(IdentName::new(
"default".into(),
DUMMY_SP,
)),
}));
new_body.push(make_require_var_item(
wrapper.id.clone(),
require_default,
));
continue;
}
}
let (import_local, assign_after_require) =
import_local_for_assignment(require_local.clone(), &mut used_names);
new_body.push(make_require_var_item(import_local.clone(), source_expr));
if let Some(assign) = assign_after_require {
new_body.push(assign);
}
// Emit: const <binding> = <require_local>;
let new_decl = VarDeclarator {
init: Some(Box::new(Expr::Ident(require_local))),
..decl.clone()
};
new_body.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(VarDecl {
decls: vec![new_decl],
..*var_decl.clone()
})))));
continue;
}
}
new_body.push(item);
}
_ => new_body.push(item),
}
}
module.body = new_body;
}
fn binding_id(ident: &Ident) -> BindingId {
(ident.sym.clone(), ident.ctxt)
}
/// Find inline Babel interop wrappers that are observably just default-import
/// aliases. Both bindings must be closed over by the matched helper shape:
///
/// - every wrapper use is a read through `.default`; and
/// - the assigned require temp is a hoisted `var` or an earlier uninitialized
/// `let` with exactly the four uses proven by the matcher (assignment,
/// marker read, and both branches).
///
/// The second condition matters because replacing the helper also removes the
/// original `temp = require(...)` assignment.
fn collect_default_only_inline_interop_bindings(
module: &Module,
unresolved_mark: Mark,
) -> HashSet<BindingId> {
let uses = BindingUseIndex::collect(module);
let mut bindings = HashSet::new();
for (item_idx, item) in module.body.iter().enumerate() {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = item else {
continue;
};
if var_decl.decls.len() != 1 {
continue;
}
let decl = &var_decl.decls[0];
let Pat::Ident(wrapper) = &decl.name else {
continue;
};
let Some(init) = &decl.init else {
continue;
};
let Some((require_local, _)) =
try_extract_inline_conditional_interop(init, unresolved_mark)
else {
continue;
};
let wrapper_id = binding_id(&wrapper.id);
let require_id = binding_id(&require_local);
if wrapper_id != require_id
&& uses.has_only_static_member_reads(&wrapper_id, "default")
&& has_available_uninitialized_temp(module, &require_id, item_idx)
&& uses.use_count(&require_id) == 4
{
bindings.insert(wrapper_id);
}
}
bindings
}
fn has_available_uninitialized_temp(
module: &Module,
binding: &BindingId,
use_item_idx: usize,
) -> bool {
module.body.iter().enumerate().any(|(decl_item_idx, item)| {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = item else {
return false;
};
let binding_is_uninitialized = var_decl.decls.iter().any(|decl| {
decl.init.is_none()
&& matches!(&decl.name, Pat::Ident(local) if binding_id(&local.id) == *binding)
});
binding_is_uninitialized
&& (var_decl.kind == VarDeclKind::Var
|| var_decl.kind == VarDeclKind::Let && decl_item_idx < use_item_idx)
})
}
struct DefaultInteropMemberRewriter<'a> {
bindings: &'a HashSet<BindingId>,
}
impl VisitMut for DefaultInteropMemberRewriter<'_> {
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
let member = match expr {
Expr::Member(member) => member,
Expr::OptChain(chain) => {
let OptChainBase::Member(member) = chain.base.as_mut() else {
return;
};
member
}
_ => return,
};
let Expr::Ident(object) = member.obj.as_ref() else {
return;
};
let MemberProp::Ident(property) = &member.prop else {
return;
};
if property.sym.as_ref() == "default" && self.bindings.contains(&binding_id(object)) {
*expr = Expr::Ident(object.clone());
}
}
}
/// Check if any expression in a sequence contains a require() call.
fn seq_has_require_call(exprs: &[Box<Expr>], unresolved_mark: Mark) -> bool {
exprs
.iter()
.any(|expr| expr_contains_require(expr, unresolved_mark))
}
fn expr_contains_require(expr: &Expr, unresolved_mark: Mark) -> bool {
match expr {
Expr::Call(call) => {
is_require_call(call, unresolved_mark).is_some()
|| match &call.callee {
Callee::Expr(callee) => expr_contains_require(callee, unresolved_mark),
_ => false,
}
}
Expr::Assign(assign) => expr_contains_require(&assign.right, unresolved_mark),
Expr::Paren(paren) => expr_contains_require(&paren.expr, unresolved_mark),
Expr::Member(member) => expr_contains_require(&member.obj, unresolved_mark),
_ => false,
}
}
/// Hoist require() calls from a sequence expression.
///
/// For `(i = require("./a.js"), require("./b.js"), expr)`:
/// - `i = require("./a.js")` → `const i = require("./a.js");` (hoisted)
/// - `require("./b.js")` → `require("./b.js");` (hoisted as bare)
/// - `expr` → returned as the remaining expression
///
/// Returns (hoisted_items, final_expression).
fn hoist_requires_from_seq(
exprs: &[Box<Expr>],
unresolved_mark: Mark,
used_names: &mut HashSet<Atom>,
) -> (Vec<ModuleItem>, Box<Expr>) {
let mut hoisted = Vec::new();
let mut remaining = Vec::new();
for expr in exprs {
let expr_ref = strip_parens(expr);
// require("...") → bare import side-effect
if let Expr::Call(call) = expr_ref {
if is_require_call(call, unresolved_mark).is_some() {
hoisted.push(ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: expr.clone(),
})));
continue;
}
}
// i = require("...") → const i = require("...")
if let Expr::Assign(assign) = expr_ref {
if assign.op == AssignOp::Assign {
if let Some(target_ident) = simple_assign_target_ident(&assign.left) {
let right = strip_parens(&assign.right);
if let Expr::Call(call) = right {
if is_require_call(call, unresolved_mark).is_some() {
let (import_local, assign_after_require) =
import_local_for_assignment(target_ident.clone(), used_names);
hoisted.push(make_require_var_item(import_local, assign.right.clone()));
if let Some(assign) = assign_after_require {
hoisted.push(assign);
}
continue;
}
}
}
}
}
// Assignments whose right side contains require() deeper in the tree:
// - c = i = require("...") → const c = i = require("...");
// - a = (i = require("...")).lib → const a = (i = require("...")).lib;
if let Expr::Assign(assign) = expr_ref {
if assign.op == AssignOp::Assign {
if let Some(outer_ident) = simple_assign_target_ident(&assign.left) {
if expr_contains_require(&assign.right, unresolved_mark) {
let (import_local, assign_after_require) =
import_local_for_assignment(outer_ident.clone(), used_names);
hoisted.push(make_var_item(import_local, assign.right.clone()));
if let Some(assign) = assign_after_require {
hoisted.push(assign);
}
continue;
}
}
}
}
remaining.push(expr.clone());
}
let final_expr = if remaining.is_empty() {
Box::new(Expr::Ident(make_ident(Atom::from("undefined"))))
} else if remaining.len() == 1 {
remaining.into_iter().next().unwrap()
} else {
Box::new(Expr::Seq(SeqExpr {
span: DUMMY_SP,
exprs: remaining,
}))
};
(hoisted, final_expr)
}
/// Match `(i = require("...")) && i.__esModule ? i : { default: i }`
/// Returns (require_local_ident, require_source_expr).
fn try_extract_inline_conditional_interop(
expr: &Expr,
unresolved_mark: Mark,
) -> Option<(Ident, Box<Expr>)> {
let expr = strip_parens(expr);
// Must be: <test> ? <cons> : <alt>
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = expr
else {
return None;
};
// test must be: (i = require("...")) && i.__esModule
// or: i && i.__esModule (where i was assigned in an outer sequence)
let test = strip_parens(test);
let Expr::Bin(bin) = test else {
return None;
};
if bin.op != BinaryOp::LogicalAnd {
return None;
}
// Right side must be: X.__esModule
let right = strip_parens(&bin.right);
let Expr::Member(member) = right else {
return None;
};
let Expr::Ident(member_obj) = strip_parens(&member.obj) else {
return None;
};
let MemberProp::Ident(IdentName { sym, .. }) = &member.prop else {
return None;
};
if sym.as_ref() != "__esModule" {
return None;
}
// Left side of && must contain the require assignment
let left = strip_parens(&bin.left);
// Pattern: (i = require("..."))
if let Expr::Assign(assign) = left {
if assign.op == AssignOp::Assign {
if let Some(target) = simple_assign_target_ident(&assign.left) {
let right_inner = strip_parens(&assign.right);
if let Expr::Call(call) = right_inner {
if is_require_call(call, unresolved_mark).is_some() {
// Verify every interop branch refers to the same assigned binding.
if member_obj.sym == target.sym
&& member_obj.ctxt == target.ctxt
&& is_same_ident_ref(cons, &target)
&& matches_default_object_for_ident(alt, &target)
{
return Some((target, assign.right.clone()));
}
}
}
}
}
}
None
}
fn simple_assign_target_ident(target: &AssignTarget) -> Option<Ident> {
if let AssignTarget::Simple(SimpleAssignTarget::Ident(bi)) = target {
Some(bi.id.clone())
} else {
None
}
}
fn is_same_ident_ref(expr: &Expr, ident: &Ident) -> bool {
let expr = strip_parens(expr);
if let Expr::Ident(id) = expr {
id.sym == ident.sym && id.ctxt == ident.ctxt
} else {
false
}
}
fn matches_default_object_for_ident(expr: &Expr, ident: &Ident) -> bool {
let Expr::Object(obj) = strip_parens(expr) else {
return false;
};
if obj.props.len() != 1 {
return false;
}
let PropOrSpread::Prop(prop) = &obj.props[0] else {
return false;
};
let Prop::KeyValue(kv) = prop.as_ref() else {
return false;
};
let key_is_default = match &kv.key {
PropName::Ident(id) => id.sym.as_ref() == "default",
PropName::Str(s) => s.value.as_str() == Some("default"),
_ => false,
};
key_is_default && is_same_ident_ref(&kv.value, ident)
}
fn import_local_for_assignment(
target: Ident,
used_names: &mut HashSet<Atom>,
) -> (Ident, Option<ModuleItem>) {
if used_names.insert(target.sym.clone()) {
return (target, None);
}
let temp = make_ident(fresh_prefixed_name(&target.sym, used_names));
let assign = ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Assign(AssignExpr {
span: DUMMY_SP,
op: AssignOp::Assign,
left: AssignTarget::Simple(SimpleAssignTarget::Ident(BindingIdent {
id: target,
type_ann: None,
})),
right: Box::new(Expr::Ident(temp.clone())),
})),
}));
(temp, Some(assign))
}
fn make_require_var_item(local: Ident, require_expr: Box<Expr>) -> ModuleItem {
make_var_item(local, require_expr)
}
fn make_var_item(local: Ident, init: Box<Expr>) -> ModuleItem {
ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(VarDecl {
span: DUMMY_SP,
ctxt: Default::default(),
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(BindingIdent {
id: local,
type_ann: None,
}),
init: Some(init),
definite: false,
}],
}))))
}
// ============================================================
// Classification helpers
// ============================================================
fn classify_item(
item: ModuleItem,
unresolved_mark: Mark,
require_bindings: &HashMap<BindingId, String>,
) -> Classified {
match item {
ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => Classified::ExistingImport(import),
ModuleItem::Stmt(ref stmt) => {
if let Some(kind) = try_classify_cjs_export(stmt, unresolved_mark, require_bindings) {
let span = match stmt {
Stmt::Expr(expr_stmt) => expr_stmt.span,
_ => DUMMY_SP,
};
return Classified::CjsExport { span, kind };
}
if let Some(kind) = try_classify_cjs_require(stmt, unresolved_mark) {
return Classified::CjsRequire(kind);
}
Classified::Keep(item)
}
other => Classified::Keep(other),
}
}
fn collect_stable_require_bindings(
module: &Module,
uses: &BindingUseIndex,
unresolved_mark: Mark,
) -> HashMap<BindingId, String> {
let mut bindings = HashMap::new();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
continue;
};
if var.decls.len() != 1 {
continue;
}
let declarator = &var.decls[0];
let Pat::Ident(binding) = &declarator.name else {
continue;
};
let Some(Expr::Call(call)) = declarator.init.as_deref().map(strip_parens) else {
continue;
};
let Some(source) = is_require_call(call, unresolved_mark) else {
continue;
};
let binding_id = (binding.id.sym.clone(), binding.id.ctxt);
if uses.has_only_static_member_reads_any(&binding_id) {
bindings.insert(binding_id, source);
}
}
bindings
}
fn remove_default_export_mirrors(classified: &mut [Classified], unresolved_mark: Mark) {
let mut saw_safe_named_default = false;
for item in classified {
if let Classified::CjsExport {
span,
kind: CjsExportKind::ModuleExportsDefault { expr },
} = item
{
if saw_safe_named_default && is_exports_default_expr(expr.as_ref(), unresolved_mark) {
let orig_span = *span;
*item = Classified::CjsExport {
span: orig_span,
kind: CjsExportKind::DefaultMirror,
};
}
saw_safe_named_default = false;
continue;
}
if matches!(
item,
Classified::CjsExport {
kind: CjsExportKind::NamedDefault { .. },
..
}
) {
saw_safe_named_default = true;
continue;
}
if saw_safe_named_default && is_safe_intervening_default_mirror_item(item, unresolved_mark)
{
continue;
}
saw_safe_named_default = false;
}
}
fn is_safe_intervening_default_mirror_item(item: &Classified, unresolved_mark: Mark) -> bool {
match item {
Classified::ExistingImport(_) | Classified::CjsRequire(_) => true,
Classified::Keep(item) => is_safe_intervening_module_item(item, unresolved_mark),
Classified::CjsExport { .. } => false,
}
}
fn is_safe_intervening_module_item(item: &ModuleItem, unresolved_mark: Mark) -> bool {
let mut finder = UnsafeDefaultMirrorInterveningFinder {
unresolved_mark,
found: false,
};
item.visit_with(&mut finder);
!finder.found
}
struct UnsafeDefaultMirrorInterveningFinder {
unresolved_mark: Mark,
found: bool,
}
impl Visit for UnsafeDefaultMirrorInterveningFinder {
fn visit_ident(&mut self, ident: &Ident) {
if is_unresolved_ident(ident, "exports", self.unresolved_mark)
|| is_unresolved_ident(ident, "module", self.unresolved_mark)
{
self.found = true;
}
}
fn visit_call_expr(&mut self, _: &CallExpr) {
self.found = true;
}
fn visit_new_expr(&mut self, _: &swc_core::ecma::ast::NewExpr) {
self.found = true;
}
fn visit_await_expr(&mut self, _: &swc_core::ecma::ast::AwaitExpr) {
self.found = true;
}
fn visit_yield_expr(&mut self, _: &swc_core::ecma::ast::YieldExpr) {
self.found = true;
}
fn visit_update_expr(&mut self, _: &swc_core::ecma::ast::UpdateExpr) {
self.found = true;
}
fn visit_unary_expr(&mut self, expr: &swc_core::ecma::ast::UnaryExpr) {
if expr.op == UnaryOp::Delete {
self.found = true;
} else {
expr.visit_children_with(self);
}
}
fn visit_assign_expr(&mut self, expr: &AssignExpr) {
match &expr.left {
AssignTarget::Simple(SimpleAssignTarget::Ident(binding))
if is_unresolved_ident(&binding.id, "exports", self.unresolved_mark)
|| is_unresolved_ident(&binding.id, "module", self.unresolved_mark) =>
{
self.found = true;
return;
}
AssignTarget::Simple(SimpleAssignTarget::Ident(_)) => {}
_ => {
self.found = true;
return;
}
}
expr.right.visit_with(self);
}
fn visit_function(&mut self, _: &swc_core::ecma::ast::Function) {}
fn visit_arrow_expr(&mut self, _: &ArrowExpr) {}
fn visit_class(&mut self, _: &swc_core::ecma::ast::Class) {
self.found = true;
}
}
/// Split compound `var s = exports.X = expr` into `var s = expr; exports.X = s;`
/// so the normal export classification can handle the extracted `exports.X = s` statement.
fn split_compound_exports(module: &mut Module, unresolved_mark: Mark) {
let mut new_body = Vec::with_capacity(module.body.len());
for item in std::mem::take(&mut module.body) {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(ref var))) = item else {
new_body.push(item);
continue;
};
let mut any_split = false;
let mut new_decls = Vec::new();
let mut export_stmts = Vec::new();
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
new_decls.push(decl.clone());
continue;
};
let Some(init) = &decl.init else {
new_decls.push(decl.clone());
continue;
};
if let Some((export_name, real_init)) =
try_extract_exports_assign(init, unresolved_mark)
{
any_split = true;
// var s = expr (stripped of exports.X wrapper)
new_decls.push(VarDeclarator {
init: Some(real_init),
..decl.clone()
});
// exports.X = s
export_stmts.push(Stmt::Expr(swc_core::ecma::ast::ExprStmt {
span: var.span,
expr: Box::new(Expr::Assign(swc_core::ecma::ast::AssignExpr {
span: DUMMY_SP,
op: AssignOp::Assign,
left: AssignTarget::Simple(SimpleAssignTarget::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(Expr::Ident(make_unresolved_ident(
"exports".into(),
unresolved_mark,
))),
prop: MemberProp::Ident(IdentName::new(export_name, DUMMY_SP)),
})),
right: Box::new(Expr::Ident(binding.id.clone())),
})),
}));
} else {
new_decls.push(decl.clone());
}
}
if any_split {
let mut new_var = (**var).clone();
new_var.decls = new_decls;
new_body.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(new_var)))));
for s in export_stmts {
new_body.push(ModuleItem::Stmt(s));
}
} else {
new_body.push(item);
}
}
module.body = new_body;
}
/// Lower `export const dep = require("dep")` into
/// `const dep = require("dep"); export { dep };` so the normal require
/// classifier can convert the declaration into an import while preserving the
/// exported binding.
fn lower_exported_cjs_requires(module: &mut Module, unresolved_mark: Mark) {
let mut new_body = Vec::with_capacity(module.body.len());
for item in std::mem::take(&mut module.body) {
let ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
span,
decl: Decl::Var(var),
})) = item
else {
new_body.push(item);
continue;
};
let has_require_decl = var
.decls
.iter()
.any(|decl| try_classify_cjs_require_declarator(decl, unresolved_mark).is_some());
if !has_require_decl {
new_body.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
span,
decl: Decl::Var(var),
})));
continue;
}
let VarDecl {
span: var_span,
ctxt,
kind,
declare,
decls,
} = *var;
for decl in decls {
let single_decl = VarDecl {
span: var_span,
ctxt,
kind,
declare,
decls: vec![decl.clone()],
};
if try_classify_cjs_require_declarator(&decl, unresolved_mark).is_some() {
let specifiers = export_specifiers_for_pat(&decl.name);
new_body.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(
single_decl,
)))));
if !specifiers.is_empty() {
new_body.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
NamedExport {
span,
specifiers,
src: None,
type_only: false,
with: None,
},
)));
}
} else {
new_body.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
span,
decl: Decl::Var(Box::new(single_decl)),
})));
}
}
}
module.body = new_body;
}
fn export_specifiers_for_pat(pat: &Pat) -> Vec<ExportSpecifier> {
find_pat_ids(pat)
.into_iter()
.map(|(sym, ctxt)| {
ExportSpecifier::Named(ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(Ident::new(sym, DUMMY_SP, ctxt)),
exported: None,
is_type_only: false,
})
})
.collect()
}
/// Extract `exports.X` from `exports.X = expr`, returning `(X, expr)`.
fn try_extract_exports_assign(expr: &Expr, unresolved_mark: Mark) -> Option<(Atom, Box<Expr>)> {
let Expr::Assign(assign) = expr else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left else {
return None;
};
let Expr::Ident(obj_id) = member.obj.as_ref() else {
return None;
};
if !is_unresolved_ident(obj_id, "exports", unresolved_mark) {
return None;
}
let prop_name = is_ident_prop(&member.prop)?;
Some((prop_name, assign.right.clone()))
}
/// Try to classify as a CJS export statement
fn try_classify_cjs_export(
stmt: &Stmt,
unresolved_mark: Mark,
require_bindings: &HashMap<BindingId, String>,
) -> Option<CjsExportKind> {
let Stmt::Expr(expr_stmt) = stmt else {
return None;
};
if let Some(kind) = try_classify_define_property_export(
expr_stmt.expr.as_ref(),
unresolved_mark,
require_bindings,
) {
return Some(kind);
}
let Expr::Assign(assign) = expr_stmt.expr.as_ref() else {
return None;
};
// Must be simple `=` assignment (not +=, etc.)
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left else {
return None;
};
// Check if obj is `module.exports` or `exports`.
if is_cjs_export_object_expr(&member.obj, unresolved_mark) {
if let Some(prop) = is_ident_prop(&member.prop) {
if prop.as_ref() == "default" {
// module.exports.default = module.exports → self-ref
if is_module_exports_expr(&assign.right, unresolved_mark) {
return Some(CjsExportKind::SelfRef);
}
return Some(CjsExportKind::NamedDefault {
expr: assign.right.clone(),
});
}
let is_void = is_void_or_undefined(&assign.right, unresolved_mark);
return Some(CjsExportKind::Named {
name: prop,
expr: assign.right.clone(),
is_void,
});
}
// bracket notation on module.exports — skip
return None;
}
// Check if member is exactly `module.exports` (obj=module, prop=exports)
if let Expr::Ident(obj_id) = member.obj.as_ref() {
if is_unresolved_ident(obj_id, "module", unresolved_mark) {
if let MemberProp::Ident(IdentName { sym, .. }) = &member.prop {
if sym.as_ref() == "exports" {
// module.exports = expr (module.exports as an assignment target)
return Some(CjsExportKind::ModuleExportsDefault {
expr: assign.right.clone(),
});
}
}
// module["exports"] = expr — skip (bracket notation)
return None;
}
}
None
}
fn try_classify_define_property_export(
expr: &Expr,
unresolved_mark: Mark,
require_bindings: &HashMap<BindingId, String>,
) -> Option<CjsExportKind> {
let Expr::Call(call) = expr else {
return None;
};
if !is_object_define_property_global_call(call, unresolved_mark) || call.args.len() != 3 {
return None;
}
if !is_cjs_export_object_expr(call.args[0].expr.as_ref(), unresolved_mark) {
return None;
}
if is_esmodule_name_arg(call.args[1].expr.as_ref())
&& is_esmodule_descriptor(call.args[2].expr.as_ref())
{
return Some(CjsExportKind::EsModuleFlag);
}
let export_name = literal_export_name_arg(call.args[1].expr.as_ref())?;
if let Some(ident) =
extract_define_property_getter_ident(call.args[2].expr.as_ref(), unresolved_mark)
{
return Some(CjsExportKind::Named {
name: export_name,
expr: Box::new(Expr::Ident(ident)),
is_void: false,
});
}
let (base, imported) = extract_define_property_getter_member(call.args[2].expr.as_ref())?;
let binding = (base.sym.clone(), base.ctxt);
let source = require_bindings.get(&binding)?.clone();
Some(CjsExportKind::ReExport {
name: export_name,
imported,
source,
binding,
})
}
/// Try to classify as a CJS require statement
fn try_classify_cjs_require(stmt: &Stmt, unresolved_mark: Mark) -> Option<CjsRequireKind> {
match stmt {
// Bare require: require('foo');
Stmt::Expr(expr_stmt) => {
if let Expr::Call(call) = expr_stmt.expr.as_ref() {
if let Some(source) = is_require_call(call, unresolved_mark) {
return Some(CjsRequireKind::Bare { source });
}
}
None
}
// var ... = require(...)[...]
Stmt::Decl(Decl::Var(var)) => {
// Must be a single declarator
if var.decls.len() != 1 {
return None;
}
try_classify_cjs_require_declarator(&var.decls[0], unresolved_mark)
}
_ => None,
}
}
fn try_classify_cjs_require_declarator(
decl: &VarDeclarator,
unresolved_mark: Mark,
) -> Option<CjsRequireKind> {
let Some(init) = &decl.init else { return None };
match &decl.name {
Pat::Ident(binding) => {
let local = binding.id.clone();
// var foo = require('bar')
if let Expr::Call(call) = init.as_ref() {
if let Some(source) = is_require_call(call, unresolved_mark) {
return Some(CjsRequireKind::Default { local, source });
}
}
// var foo = require('bar').baz or require('bar').default
if let Expr::Member(member) = init.as_ref() {
if let Expr::Call(call) = member.obj.as_ref() {
if let Some(source) = is_require_call(call, unresolved_mark) {
if let Some(prop) = is_ident_prop(&member.prop) {
if prop.as_ref() == "default" {
return Some(CjsRequireKind::DefaultProp { local, source });
} else {
return Some(CjsRequireKind::NamedProp {
prop,
local,
source,
});
}
}
// Invalid ident prop or bracket notation → skip
return None;
}
}
}
None
}
Pat::Object(obj_pat) => {
// var { a, b: c } = require('foo')
if let Expr::Call(call) = init.as_ref() {
if let Some(source) = is_require_call(call, unresolved_mark) {
let mut specifiers: Vec<(Atom, Ident)> = Vec::new();
for prop in &obj_pat.props {
match prop {
ObjectPatProp::KeyValue(kv) => {
// { b: c } → import { b as c }
let imported = match &kv.key {
swc_core::ecma::ast::PropName::Ident(i) => i.sym.clone(),
swc_core::ecma::ast::PropName::Str(s) => {
Atom::from(s.value.as_str().unwrap_or(""))
}
_ => return None,
};
let local = extract_binding_ident(&kv.value)?;
specifiers.push((imported, local));
}
ObjectPatProp::Assign(a) => {
// { foo } → import { foo }
let ident = a.key.id.clone();
let name = ident.sym.clone();
specifiers.push((name, ident));
}
ObjectPatProp::Rest(_) => {
// rest spread — skip transformation
return None;
}
}
}
return Some(CjsRequireKind::Named { specifiers, source });
}
}
// var { bar } = require('foo').baz — complex, skip
None
}
_ => None,
}
}
fn extract_binding_ident(pat: &Pat) -> Option<Ident> {
match pat {
Pat::Ident(bi) => Some(bi.id.clone()),
Pat::Assign(a) => extract_binding_ident(&a.left),
_ => None,
}
}
// ============================================================
// Helper functions
// ============================================================
/// Check if call is `require('...')` and return the source string
fn is_require_call(call: &CallExpr, unresolved_mark: Mark) -> Option<String> {
let Callee::Expr(callee) = &call.callee else {
return None;
};
let Expr::Ident(id) = callee.as_ref() else {
return None;
};
if !is_unresolved_ident(id, "require", unresolved_mark) {
return None;
}
if call.args.len() != 1 {
return None;
}
let arg = &call.args[0];
if arg.spread.is_some() {
return None;
}
if let Expr::Lit(Lit::Str(s)) = arg.expr.as_ref() {
Some(s.value.as_str().unwrap_or("").to_string())
} else {
None
}
}
/// Check if prop is an identifier (dot notation) and return name
/// Also accepts computed access with a valid JS identifier string literal
fn is_ident_prop(prop: &MemberProp) -> Option<Atom> {
match prop {
MemberProp::Ident(ident_name) => Some(ident_name.sym.clone()),
MemberProp::Computed(computed) => {
if let Expr::Lit(Lit::Str(s)) = computed.expr.as_ref() {
let s_str = s.value.as_str()?;
if is_valid_js_ident(s_str) {
Some(Atom::from(s_str))
} else {
None
}
} else {
None
}
}
_ => None,
}
}
/// Check if expr is `void N` or `undefined`
fn is_void_or_undefined(expr: &Expr, unresolved_mark: Mark) -> bool {
match expr {
Expr::Unary(unary) if unary.op == UnaryOp::Void => true,
Expr::Ident(id) if is_undefined_ident(id, unresolved_mark) => true,
_ => false,
}
}
/// Check if expr is `module.exports`
fn is_module_exports_expr(expr: &Expr, unresolved_mark: Mark) -> bool {
if let Expr::Member(MemberExpr { obj, prop, .. }) = expr {
if let Expr::Ident(id) = obj.as_ref() {
if is_unresolved_ident(id, "module", unresolved_mark) {
if let MemberProp::Ident(IdentName { sym, .. }) = prop {
return sym.as_ref() == "exports";
}
}
}
}
false
}
fn is_cjs_export_object_expr(expr: &Expr, unresolved_mark: Mark) -> bool {
let expr = strip_parens(expr);
if is_module_exports_expr(expr, unresolved_mark) {
return true;
}
let Expr::Ident(id) = expr else {
return false;
};
is_unresolved_ident(id, "exports", unresolved_mark)
}
fn is_object_define_property_global_call(call: &CallExpr, unresolved_mark: Mark) -> bool {
let Callee::Expr(callee) = &call.callee else {
return false;
};
is_unresolved_member_expr(callee.as_ref(), "Object", "defineProperty", unresolved_mark)
}
fn is_esmodule_name_arg(expr: &Expr) -> bool {
matches!(strip_parens(expr), Expr::Lit(Lit::Str(str)) if str.value.as_str() == Some("__esModule"))
}
fn literal_export_name_arg(expr: &Expr) -> Option<Atom> {
let Expr::Lit(Lit::Str(str)) = strip_parens(expr) else {
return None;
};
let value = str.value.as_str()?;
if is_valid_js_ident(value) {
Some(value.into())
} else {
None
}
}
fn is_esmodule_descriptor(expr: &Expr) -> bool {
let Expr::Object(object) = strip_parens(expr) else {
return false;
};
let mut has_value_true = false;
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return false;
};
let Prop::KeyValue(entry) = prop.as_ref() else {
return false;
};
let Some(name) = prop_name_as_atom(&entry.key) else {
return false;
};
match name.as_ref() {
"value" => {
if !matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(value)) if value.value) {
return false;
}
has_value_true = true;
}
"enumerable" | "configurable" | "writable" => {
if !matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(_))) {
return false;
}
}
_ => return false,
}
}
has_value_true
}
fn extract_define_property_getter_ident(expr: &Expr, unresolved_mark: Mark) -> Option<Ident> {
let expr = extract_define_property_getter_expr(expr)?;
let Expr::Ident(ident) = expr.as_ref() else {
return None;
};
if ident.ctxt.outer() == unresolved_mark {
return None;
}
Some(ident.clone())
}
fn extract_define_property_getter_member(expr: &Expr) -> Option<(Ident, Atom)> {
let expr = extract_define_property_getter_expr(expr)?;
let Expr::Member(member) = strip_parens(&expr) else {
return None;
};
let Expr::Ident(base) = strip_parens(&member.obj) else {
return None;
};
Some((base.clone(), is_ident_prop(&member.prop)?))
}
fn extract_define_property_getter_expr(expr: &Expr) -> Option<Box<Expr>> {
let Expr::Object(object) = strip_parens(expr) else {
return None;
};
let mut has_enumerable_true = false;
let mut has_enumerable = false;
let mut has_configurable = false;
let mut getter_expr = None;
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return None;
};
match prop.as_ref() {
Prop::KeyValue(entry) => match prop_name_as_atom(&entry.key).as_deref() {
Some("enumerable") => {
if has_enumerable || !matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(_))) {
return None;
}
has_enumerable = true;
has_enumerable_true =
matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(value)) if value.value);
}
Some("get") => {
if getter_expr.is_some() {
return None;
}
getter_expr = Some(extract_getter_expr_return_expr(entry.value.as_ref())?);
}
Some("configurable") => {
if has_configurable {
return None;
}
if !matches!(entry.value.as_ref(), Expr::Lit(Lit::Bool(_))) {
return None;
}
has_configurable = true;
}
_ => return None,
},
Prop::Method(method) => {
if matches!(prop_name_as_atom(&method.key).as_deref(), Some("get")) {
if getter_expr.is_some() {
return None;
}
if !method.function.params.is_empty()
|| method.function.is_async
|| method.function.is_generator
{
return None;
}
getter_expr = Some(extract_single_return_expr(method.function.body.as_ref()?)?);
} else {
return None;
}
}
_ => return None,
}
}
has_enumerable_true.then_some(getter_expr).flatten()
}
fn is_unresolved_ident(id: &Ident, name: &str, unresolved_mark: Mark) -> bool {
id.sym.as_ref() == name && id.ctxt.outer() == unresolved_mark
}
fn is_undefined_ident(id: &Ident, unresolved_mark: Mark) -> bool {
id.sym.as_ref() == "undefined"
&& (id.ctxt.outer() == unresolved_mark || id.ctxt == SyntaxContext::empty())
}
/// Check if a string is a valid JS identifier
fn is_valid_js_ident(s: &str) -> bool {
if s.is_empty() {
return false;
}
let mut chars = s.chars();
let first = chars.next().unwrap();
if !first.is_alphabetic() && first != '_' && first != '$' {
return false;
}
chars.all(|c| c.is_alphanumeric() || c == '_' || c == '$')
}
fn make_str(value: &str) -> Str {
Str {
span: DUMMY_SP,
value: value.into(),
raw: None,
}
}
fn make_ident(sym: Atom) -> Ident {
Ident::new_no_ctxt(sym, DUMMY_SP)
}
fn make_unresolved_ident(sym: Atom, unresolved_mark: Mark) -> Ident {
Ident::new(
sym,
DUMMY_SP,
SyntaxContext::empty().apply_mark(unresolved_mark),
)
}
/// Extract the span from a ModuleItem. Returns DUMMY_SP for items without
/// a meaningful span (e.g. synthesized items).
fn module_item_span(item: &ModuleItem) -> Span {
match item {
ModuleItem::Stmt(stmt) => match stmt {
Stmt::Expr(expr_stmt) => expr_stmt.span,
Stmt::Decl(Decl::Var(var)) => var.span,
Stmt::Decl(Decl::Fn(f)) => f.function.span,
_ => DUMMY_SP,
},
ModuleItem::ModuleDecl(decl) => match decl {
ModuleDecl::Import(i) => i.span,
ModuleDecl::ExportDecl(e) => e.span,
ModuleDecl::ExportNamed(e) => e.span,
ModuleDecl::ExportDefaultExpr(e) => e.span,
ModuleDecl::ExportDefaultDecl(e) => e.span,
ModuleDecl::ExportAll(e) => e.span,
_ => DUMMY_SP,
},
}
}
fn wtf8_to_string(value: &swc_core::atoms::Wtf8Atom) -> String {
value.as_str().unwrap_or("").to_string()
}
fn collect_all_declared_names(module: &Module) -> HashSet<Atom> {
struct Collector {
names: HashSet<Atom>,
}
impl Visit for Collector {
fn visit_pat(&mut self, pat: &Pat) {
collect_pat_names(pat, &mut self.names);
pat.visit_children_with(self);
}
fn visit_import_decl(&mut self, import: &ImportDecl) {
for spec in &import.specifiers {
match spec {
ImportSpecifier::Named(named) => {
self.names.insert(named.local.sym.clone());
}
ImportSpecifier::Default(default) => {
self.names.insert(default.local.sym.clone());
}
ImportSpecifier::Namespace(namespace) => {
self.names.insert(namespace.local.sym.clone());
}
}
}
}
fn visit_decl(&mut self, decl: &Decl) {
match decl {
Decl::Fn(function) => {
self.names.insert(function.ident.sym.clone());
function.function.visit_with(self);
}
Decl::Class(class) => {
self.names.insert(class.ident.sym.clone());
class.class.visit_with(self);
}
_ => decl.visit_children_with(self),
}
}
}
let mut collector = Collector {
names: HashSet::new(),
};
module.visit_with(&mut collector);
collector.names
}
fn collect_conflicting_import_renames(
items: &[ModuleItem],
conflicts: &HashSet<Atom>,
used_names: &mut HashSet<Atom>,
renames: &mut Vec<BindingRename>,
) {
for item in items {
let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
continue;
};
for spec in &import.specifiers {
let local = match spec {
ImportSpecifier::Named(named) => &named.local,
ImportSpecifier::Default(default) => &default.local,
ImportSpecifier::Namespace(namespace) => &namespace.local,
};
collect_conflicting_ident_rename(local, conflicts, used_names, renames);
}
}
}
fn collect_conflicting_decl_renames(
decl: &Decl,
conflicts: &HashSet<Atom>,
used_names: &mut HashSet<Atom>,
renames: &mut Vec<BindingRename>,
) {
match decl {
Decl::Var(var) => {
for d in &var.decls {
collect_conflicting_pat_renames(&d.name, conflicts, used_names, renames);
}
}
Decl::Fn(f) => collect_conflicting_ident_rename(&f.ident, conflicts, used_names, renames),
Decl::Class(c) => {
collect_conflicting_ident_rename(&c.ident, conflicts, used_names, renames)
}
_ => {}
}
}
fn collect_conflicting_pat_renames(
pat: &Pat,
conflicts: &HashSet<Atom>,
used_names: &mut HashSet<Atom>,
renames: &mut Vec<BindingRename>,
) {
match pat {
Pat::Ident(id) => collect_conflicting_ident_rename(&id.id, conflicts, used_names, renames),
Pat::Array(arr) => {
for p in arr.elems.iter().flatten() {
collect_conflicting_pat_renames(p, conflicts, used_names, renames);
}
}
Pat::Object(obj) => {
for prop in &obj.props {
match prop {
ObjectPatProp::KeyValue(kv) => {
collect_conflicting_pat_renames(&kv.value, conflicts, used_names, renames);
}
ObjectPatProp::Assign(a) => {
collect_conflicting_ident_rename(&a.key.id, conflicts, used_names, renames);
}
ObjectPatProp::Rest(r) => {
collect_conflicting_pat_renames(&r.arg, conflicts, used_names, renames);
}
}
}
}
Pat::Assign(a) => collect_conflicting_pat_renames(&a.left, conflicts, used_names, renames),
Pat::Rest(r) => collect_conflicting_pat_renames(&r.arg, conflicts, used_names, renames),
_ => {}
}
}
fn collect_conflicting_ident_rename(
ident: &Ident,
conflicts: &HashSet<Atom>,
used_names: &mut HashSet<Atom>,
renames: &mut Vec<BindingRename>,
) {
if !conflicts.contains(&ident.sym) {
return;
}
let new = fresh_prefixed_name(&ident.sym, used_names);
renames.push(BindingRename {
old: (ident.sym.clone(), ident.ctxt),
new,
});
}
fn fresh_prefixed_name(name: &Atom, used_names: &mut HashSet<Atom>) -> Atom {
let base = format!("_{name}");
let atom = Atom::from(base);
if used_names.insert(atom.clone()) {
return atom;
}
let mut index = 2usize;
loop {
let candidate = Atom::from(format!("_{name}{index}"));
if used_names.insert(candidate.clone()) {
return candidate;
}
index += 1;
}
}
fn rename_export_kind(kind: &mut CjsExportKind, renames: &[BindingRename]) {
match kind {
CjsExportKind::ModuleExportsDefault { expr }
| CjsExportKind::Named { expr, .. }
| CjsExportKind::NamedDefault { expr } => {
rename_bindings(expr.as_mut(), renames);
}
CjsExportKind::EsModuleFlag
| CjsExportKind::ReExport { .. }
| CjsExportKind::DefaultMirror
| CjsExportKind::SelfRef => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn get_or_insert_records_source_order_once() {
let mut order = Vec::new();
let mut map = HashMap::new();
get_or_insert(&mut order, &mut map, "react".to_string());
get_or_insert(&mut order, &mut map, "react".to_string());
get_or_insert(&mut order, &mut map, "lodash".to_string());
assert_eq!(order, vec!["react", "lodash"]);
assert!(map.contains_key("react"));
assert!(map.contains_key("lodash"));
}
}