crates/core/src/rules/un_object_spread.rs
GitHubuse std::collections::{HashMap, HashSet};
use swc_core::atoms::Atom;
use swc_core::common::{Mark, DUMMY_SP};
use swc_core::ecma::ast::{
AssignOp, AssignTarget, BinaryOp, BlockStmt, BlockStmtOrExpr, CallExpr, Callee, Decl, Expr,
ForInStmt, Function, Ident, ImportSpecifier, Lit, MemberExpr, MemberProp, Module, ModuleDecl,
ModuleItem, ObjectLit, Pat, Prop, PropName, PropOrSpread, ReturnStmt, SimpleAssignTarget,
SpreadElement, Stmt, UnaryExpr, UnaryOp,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};
use crate::facts::{HelperKind, ModuleFactsMap, TypeScriptHelperKind};
use super::cross_module_helper_refs::{
collect_cross_module_helper_refs, collect_cross_module_ts_helper_refs,
cross_module_member_helper_kind, cross_module_ts_member_helper,
};
use super::helper_matcher::{
binding_key, member_prop_name, remaining_refs_outside_declarations, remove_fn_decls_by_binding,
remove_var_declarators_by_binding, static_member_prop_name, var_declarator_binding_key,
};
use super::transpiler_helper_utils::{
tslib_member_helper_kind, BindingKey, LocalHelperContext, TranspilerHelperKind,
};
use crate::utils::paren::strip_parens;
/// Detects and replaces `_extends` and `_objectSpread2` helper calls with
/// object spread syntax.
///
/// Both `_extends` and `_objectSpread2` mutate and return their first argument
/// (like Object.assign). Only transform when the first arg is a safe fresh object
/// literal target, which guarantees no mutation/identity side effects:
/// `_extends({}, obj1, obj2)` → `{ ...obj1, ...obj2 }`
/// `_extends({ a: 1 }, obj1)` → `{ a: 1, ...obj1 }`
/// `_objectSpread2({}, y)` → `{ ...y }`
/// `_extends(target, source)` → left as-is (mutation semantics)
/// `_objectSpread2(existing, {a: 1})` → left as-is (mutation semantics)
pub struct UnObjectSpread<'a> {
module_facts: Option<&'a ModuleFactsMap>,
current_filename: Option<&'a str>,
unresolved_mark: Option<Mark>,
}
impl UnObjectSpread<'_> {
pub fn new() -> Self {
Self {
module_facts: None,
current_filename: None,
unresolved_mark: None,
}
}
pub fn new_with_mark(unresolved_mark: Mark) -> Self {
Self {
module_facts: None,
current_filename: None,
unresolved_mark: Some(unresolved_mark),
}
}
}
impl<'a> UnObjectSpread<'a> {
pub fn new_with_facts(module_facts: &'a ModuleFactsMap) -> Self {
Self {
module_facts: Some(module_facts),
current_filename: None,
unresolved_mark: None,
}
}
pub(crate) fn run_with_helpers(
module: &mut Module,
unresolved_mark: Mark,
local_helpers: &LocalHelperContext,
module_facts: Option<&ModuleFactsMap>,
current_filename: Option<&str>,
) {
run_un_object_spread(
module,
Some(unresolved_mark),
local_helpers,
module_facts,
current_filename,
);
}
}
impl VisitMut for UnObjectSpread<'_> {
fn visit_mut_module(&mut self, module: &mut Module) {
let local_helpers = self.unresolved_mark.map_or_else(
|| LocalHelperContext::collect(module),
|mark| LocalHelperContext::collect_with_mark(module, mark),
);
run_un_object_spread(
module,
self.unresolved_mark,
&local_helpers,
self.module_facts,
self.current_filename,
);
}
}
fn run_un_object_spread(
module: &mut Module,
unresolved_mark: Option<Mark>,
local_helper_context: &LocalHelperContext,
module_facts: Option<&ModuleFactsMap>,
current_filename: Option<&str>,
) {
let esbuild_aliases = collect_esbuild_object_builtin_aliases(module, unresolved_mark);
let esbuild_define_normal_prop_helpers = if esbuild_aliases.has_spread_values_signals() {
collect_esbuild_define_normal_prop_helpers(module, &esbuild_aliases)
} else {
HashSet::new()
};
let mut local_helpers: HashMap<BindingKey, TranspilerHelperKind> = local_helper_context
.helpers()
.iter()
.filter(|(_, kind)| {
**kind == TranspilerHelperKind::Extends
|| **kind == TranspilerHelperKind::ObjectSpread
|| **kind == TranspilerHelperKind::DefineProperty
|| **kind == TranspilerHelperKind::HelperDependency
})
.map(|(key, kind)| (key.clone(), *kind))
.collect();
let uninitialized_object_spread_stubs = collect_uninitialized_object_spread_stubs(module);
let mangled_esbuild_helpers = collect_mangled_esbuild_object_spread_helpers(
module,
&esbuild_aliases,
&esbuild_define_normal_prop_helpers,
);
local_helpers.extend(uninitialized_object_spread_stubs.clone());
local_helpers.extend(mangled_esbuild_helpers.clone());
let mut helpers = local_helpers.clone();
if let Some(module_facts) = module_facts {
helpers.extend(collect_cross_module_object_spread_helpers(
module,
module_facts,
current_filename,
));
}
let cross_module_helper_refs = module_facts
.map(|facts| {
collect_cross_module_helper_refs(module, facts, current_filename, |kind| {
matches!(
kind,
TranspilerHelperKind::Extends | TranspilerHelperKind::ObjectSpread
)
})
})
.unwrap_or_default();
helpers.extend(
cross_module_helper_refs
.direct
.iter()
.map(|(key, kind)| (key.clone(), *kind)),
);
let cross_module_ts_assign_refs = module_facts
.map(|facts| {
collect_cross_module_ts_helper_refs(
module,
facts,
current_filename,
TypeScriptHelperKind::Assign,
)
})
.unwrap_or_default();
helpers.extend(
cross_module_ts_assign_refs
.direct
.iter()
.map(|key| (key.clone(), TranspilerHelperKind::Extends)),
);
let swc_numeric_helper_namespaces =
collect_swc_numeric_helper_namespaces(module, unresolved_mark);
let tslib_namespaces = local_helper_context.tslib_namespaces();
let has_inline_object_spread_call = has_inline_object_spread_call(
module,
&esbuild_aliases,
&esbuild_define_normal_prop_helpers,
);
if helpers.is_empty()
&& cross_module_ts_assign_refs.namespaces.is_empty()
&& swc_numeric_helper_namespaces.is_empty()
&& cross_module_helper_refs.namespaces.is_empty()
&& tslib_namespaces.is_empty()
&& !has_inline_object_spread_call
{
return;
}
let mut replacer = SpreadReplacer {
helpers: &helpers,
cross_module_helper_namespaces: &cross_module_helper_refs.namespaces,
cross_module_ts_assign_namespaces: &cross_module_ts_assign_refs.namespaces,
swc_numeric_helper_namespaces: &swc_numeric_helper_namespaces,
tslib_namespaces,
esbuild_aliases: &esbuild_aliases,
esbuild_define_normal_prop_helpers: &esbuild_define_normal_prop_helpers,
};
module.visit_mut_with(&mut replacer);
remove_unused_numeric_helper_namespace_decls(module, &swc_numeric_helper_namespaces);
// Only remove root helpers whose calls were fully transformed. Dependencies
// referenced by retained helpers must stay with those helpers.
let local_root_helpers: HashMap<BindingKey, TranspilerHelperKind> = local_helpers
.iter()
.filter(|(_, kind)| {
matches!(
kind,
TranspilerHelperKind::Extends | TranspilerHelperKind::ObjectSpread
)
})
.map(|(key, kind)| (key.clone(), *kind))
.collect();
let mut helper_dependency_cleanup_candidates: HashSet<_> =
uninitialized_object_spread_stubs.keys().cloned().collect();
helper_dependency_cleanup_candidates.extend(
mangled_esbuild_helpers
.iter()
.filter(|(_, kind)| **kind == TranspilerHelperKind::HelperDependency)
.map(|(key, _)| key.clone()),
);
helper_dependency_cleanup_candidates.extend(esbuild_define_normal_prop_helpers.iter().cloned());
local_helper_context.remove_helpers_with_dependencies(module, local_root_helpers);
remove_unused_helper_dependency_decls(module, &helper_dependency_cleanup_candidates);
// The collected alias sets cover any unused Object alias in the module, so
// only sweep them when esbuild helper machinery was actually recognized;
// a recovered Babel/SWC helper alone says nothing about stray aliases.
if !mangled_esbuild_helpers.is_empty()
|| !esbuild_define_normal_prop_helpers.is_empty()
|| has_inline_object_spread_call
{
remove_unused_esbuild_object_builtin_aliases(module, &esbuild_aliases);
}
}
impl Default for UnObjectSpread<'_> {
fn default() -> Self {
Self::new()
}
}
fn collect_uninitialized_object_spread_stubs(
module: &Module,
) -> HashMap<BindingKey, TranspilerHelperKind> {
let mut helpers = HashMap::new();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
continue;
};
for decl in &var.decls {
if decl.init.is_some() {
continue;
}
let Pat::Ident(binding) = &decl.name else {
continue;
};
if matches!(binding.id.sym.as_ref(), "__spreadValues" | "__spreadProps") {
helpers.insert(
(binding.id.sym.clone(), binding.id.ctxt),
TranspilerHelperKind::HelperDependency,
);
}
}
}
helpers
}
// esbuild object-spread detection is intentionally kept in this rule rather than
// in the central `transpiler_helper_utils` scanner. The Babel/SWC matchers there
// classify a function purely by its own AST shape (`fn(&Function) -> bool`), but
// esbuild's `__spreadValues` / `__spreadProps` can only be recognized against
// module-wide *state*: esbuild mangles `Object.defineProperty`,
// `Object.prototype.hasOwnProperty`, etc. into local aliases, and the spread
// helpers are matched relative to those aliases (`EsbuildObjectBuiltinAliases`)
// and the `__defNormalProp` helper. Threading that bundler-specific state through
// the generic scanner would couple it to esbuild internals, so per
// docs/helper-detection.md this stateful detection stays rule-local.
#[derive(Default)]
struct EsbuildObjectBuiltinAliases {
define_property: HashSet<BindingKey>,
define_properties: HashSet<BindingKey>,
get_own_property_descriptors: HashSet<BindingKey>,
get_own_property_symbols: HashSet<BindingKey>,
has_own_property: HashSet<BindingKey>,
property_is_enumerable: HashSet<BindingKey>,
}
impl EsbuildObjectBuiltinAliases {
fn has_spread_values_signals(&self) -> bool {
!self.define_property.is_empty()
&& !self.get_own_property_symbols.is_empty()
&& !self.has_own_property.is_empty()
&& !self.property_is_enumerable.is_empty()
}
fn has_spread_props_signals(&self) -> bool {
!self.define_properties.is_empty() && !self.get_own_property_descriptors.is_empty()
}
fn dependency_keys(&self) -> impl Iterator<Item = BindingKey> + '_ {
self.define_property
.iter()
.chain(&self.define_properties)
.chain(&self.get_own_property_descriptors)
.chain(&self.get_own_property_symbols)
.chain(&self.has_own_property)
.chain(&self.property_is_enumerable)
.cloned()
}
}
fn remove_unused_esbuild_object_builtin_aliases(
module: &mut Module,
aliases: &EsbuildObjectBuiltinAliases,
) {
let candidates: HashSet<_> = aliases.dependency_keys().collect();
if candidates.is_empty() {
return;
}
let remaining = remaining_refs_outside_declarations(module, &candidates, &candidates);
let removable: HashSet<_> = candidates
.into_iter()
.filter(|key| !remaining.contains(key))
.collect();
if !removable.is_empty() {
remove_var_declarators_by_binding(&mut module.body, &removable);
}
}
fn remove_unused_helper_dependency_decls(module: &mut Module, candidates: &HashSet<BindingKey>) {
if candidates.is_empty() {
return;
}
let remaining = remaining_refs_outside_declarations(module, candidates, candidates);
let removable: HashSet<_> = candidates
.iter()
.filter(|key| !remaining.contains(*key))
.cloned()
.collect();
if removable.is_empty() {
return;
}
remove_fn_decls_by_binding(module, &removable);
remove_var_declarators_by_binding(&mut module.body, &removable);
}
fn collect_mangled_esbuild_object_spread_helpers(
module: &Module,
aliases: &EsbuildObjectBuiltinAliases,
define_normal_prop_helpers: &HashSet<BindingKey>,
) -> HashMap<BindingKey, TranspilerHelperKind> {
if !aliases.has_spread_values_signals() && !aliases.has_spread_props_signals() {
return HashMap::new();
}
let mut helpers = HashMap::new();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
continue;
};
for decl in &var.decls {
let Some(key) = var_declarator_binding_key(decl) else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
if (aliases.has_spread_values_signals()
&& !define_normal_prop_helpers.is_empty()
&& esbuild_spread_values_helper_matches(init, define_normal_prop_helpers, aliases))
|| (aliases.has_spread_props_signals()
&& esbuild_spread_props_helper_matches(
init,
aliases,
define_normal_prop_helpers,
))
{
helpers.insert(key, TranspilerHelperKind::ObjectSpread);
}
}
}
if helpers.is_empty() {
return helpers;
}
helpers.extend(
aliases
.dependency_keys()
.map(|key| (key, TranspilerHelperKind::HelperDependency)),
);
helpers.extend(
define_normal_prop_helpers
.iter()
.cloned()
.map(|key| (key, TranspilerHelperKind::HelperDependency)),
);
helpers
}
fn collect_esbuild_object_builtin_aliases(
module: &Module,
unresolved_mark: Option<Mark>,
) -> EsbuildObjectBuiltinAliases {
let mut aliases = EsbuildObjectBuiltinAliases::default();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
continue;
};
for decl in &var.decls {
let Some(key) = var_declarator_binding_key(decl) else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
match object_builtin_alias_kind(init, unresolved_mark) {
Some("defineProperty") => {
aliases.define_property.insert(key);
}
Some("defineProperties") => {
aliases.define_properties.insert(key);
}
Some("getOwnPropertyDescriptors") => {
aliases.get_own_property_descriptors.insert(key);
}
Some("getOwnPropertySymbols") => {
aliases.get_own_property_symbols.insert(key);
}
Some("hasOwnProperty") => {
aliases.has_own_property.insert(key);
}
Some("propertyIsEnumerable") => {
aliases.property_is_enumerable.insert(key);
}
_ => {}
}
}
}
aliases
}
fn object_builtin_alias_kind(expr: &Expr, unresolved_mark: Option<Mark>) -> Option<&'static str> {
let is_global_object = |obj: &Ident| {
obj.sym.as_ref() == "Object" && unresolved_mark.is_none_or(|mark| obj.ctxt.outer() == mark)
};
let Expr::Member(member) = strip_parens(expr) else {
return None;
};
if let Expr::Ident(obj) = member.obj.as_ref() {
if is_global_object(obj) {
match static_member_prop_name(&member.prop) {
Some("defineProperty") => return Some("defineProperty"),
Some("defineProperties") => return Some("defineProperties"),
Some("getOwnPropertyDescriptors") => return Some("getOwnPropertyDescriptors"),
Some("getOwnPropertySymbols") => return Some("getOwnPropertySymbols"),
_ => {}
}
}
}
let Expr::Member(proto_member) = member.obj.as_ref() else {
return None;
};
let Expr::Ident(obj) = proto_member.obj.as_ref() else {
return None;
};
if !is_global_object(obj) || !member_prop_name(&proto_member.prop, "prototype") {
return None;
}
match static_member_prop_name(&member.prop) {
Some("hasOwnProperty") => Some("hasOwnProperty"),
Some("propertyIsEnumerable") => Some("propertyIsEnumerable"),
_ => None,
}
}
fn collect_esbuild_define_normal_prop_helpers(
module: &Module,
aliases: &EsbuildObjectBuiltinAliases,
) -> HashSet<BindingKey> {
let mut helpers = HashSet::new();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
continue;
};
for decl in &var.decls {
let Some(key) = var_declarator_binding_key(decl) else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
if esbuild_define_normal_prop_helper_matches(init, aliases) {
helpers.insert(key);
}
}
}
helpers
}
fn esbuild_define_normal_prop_helper_matches(
expr: &Expr,
aliases: &EsbuildObjectBuiltinAliases,
) -> bool {
let Some((target, key, value, body)) = helper_three_param_body(expr) else {
return false;
};
let mut marker = DefineNormalPropMarker {
target,
key,
value,
define_property_aliases: &aliases.define_property,
saw_define_property: false,
saw_fallback_assign: false,
};
body.visit_with(&mut marker);
marker.saw_define_property && marker.saw_fallback_assign
}
fn esbuild_spread_values_helper_matches(
expr: &Expr,
define_normal_prop_helpers: &HashSet<BindingKey>,
aliases: &EsbuildObjectBuiltinAliases,
) -> bool {
let Some((target, source, block)) = helper_two_param_block(expr) else {
return false;
};
if !block_returns_binding(block, target) {
return false;
}
let mut marker = SpreadValuesMarker {
target,
source,
define_normal_prop_helpers,
has_own_property_aliases: &aliases.has_own_property,
saw_for_in_source: false,
saw_has_own_call: false,
saw_define_normal_prop_call: false,
};
block.visit_with(&mut marker);
marker.saw_for_in_source && marker.saw_has_own_call && marker.saw_define_normal_prop_call
}
fn esbuild_spread_props_helper_matches(
expr: &Expr,
aliases: &EsbuildObjectBuiltinAliases,
define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
let Some((target, source, body)) = helper_two_param_body(expr) else {
return false;
};
spread_props_expr_matches(body, target, source, aliases, define_normal_prop_helpers)
}
fn helper_three_param_body(expr: &Expr) -> Option<(&Ident, &Ident, &Ident, &Expr)> {
match strip_parens(expr) {
Expr::Arrow(arrow) => {
if arrow.params.len() != 3 {
return None;
}
let target = pat_ident(&arrow.params[0])?;
let key = pat_ident(&arrow.params[1])?;
let value = pat_ident(&arrow.params[2])?;
Some((target, key, value, arrow_body_expr(&arrow.body)?))
}
_ => None,
}
}
fn helper_two_param_body(expr: &Expr) -> Option<(&Ident, &Ident, &Expr)> {
match strip_parens(expr) {
Expr::Arrow(arrow) => {
if arrow.params.len() != 2 {
return None;
}
let target = pat_ident(&arrow.params[0])?;
let source = pat_ident(&arrow.params[1])?;
Some((target, source, arrow_body_expr(&arrow.body)?))
}
Expr::Fn(fn_expr) => {
let (target, source) = function_two_param_idents(&fn_expr.function)?;
let body = function_single_return_expr(&fn_expr.function)?;
Some((target, source, body))
}
_ => None,
}
}
fn helper_two_param_block(expr: &Expr) -> Option<(&Ident, &Ident, &BlockStmt)> {
match strip_parens(expr) {
Expr::Arrow(arrow) => {
if arrow.params.len() != 2 {
return None;
}
let target = pat_ident(&arrow.params[0])?;
let source = pat_ident(&arrow.params[1])?;
let BlockStmtOrExpr::BlockStmt(block) = arrow.body.as_ref() else {
return None;
};
Some((target, source, block))
}
Expr::Fn(fn_expr) => {
let (target, source) = function_two_param_idents(&fn_expr.function)?;
Some((target, source, fn_expr.function.body.as_ref()?))
}
_ => None,
}
}
fn arrow_body_expr(body: &BlockStmtOrExpr) -> Option<&Expr> {
match body {
BlockStmtOrExpr::Expr(expr) => Some(expr),
BlockStmtOrExpr::BlockStmt(block) => {
if block.stmts.len() != 1 {
return None;
}
let Stmt::Return(ReturnStmt { arg: Some(arg), .. }) = &block.stmts[0] else {
return None;
};
Some(arg)
}
}
}
fn function_two_param_idents(func: &Function) -> Option<(&Ident, &Ident)> {
if func.params.len() != 2 {
return None;
}
Some((
pat_ident(&func.params[0].pat)?,
pat_ident(&func.params[1].pat)?,
))
}
fn function_single_return_expr(func: &Function) -> Option<&Expr> {
let body = func.body.as_ref()?;
if body.stmts.len() != 1 {
return None;
}
let Stmt::Return(ReturnStmt { arg: Some(arg), .. }) = &body.stmts[0] else {
return None;
};
Some(arg)
}
fn block_returns_binding(block: &BlockStmt, binding: &Ident) -> bool {
matches!(
block.stmts.last(),
Some(Stmt::Return(ReturnStmt { arg: Some(arg), .. }))
if is_binding_ref(arg, binding)
)
}
fn spread_props_expr_matches(
expr: &Expr,
target: &Ident,
source: &Ident,
aliases: &EsbuildObjectBuiltinAliases,
define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
// esbuild only ever emits `__spreadProps` alongside `__spreadValues`, whose
// body calls a `__defNormalProp` helper that survives minification. Demand
// that matched helper — not merely the alias preamble — as corroboration:
// the bare two-param defineProperties shape is just as likely a
// user-written descriptor-copy utility, whose semantics (mutates target,
// preserves accessors) object spread would break.
if define_normal_prop_helpers.is_empty() {
return false;
}
let Expr::Call(call) = strip_parens(expr) else {
return false;
};
if call.args.len() != 2 || call.args.iter().any(|arg| arg.spread.is_some()) {
return false;
}
if !callee_matches_alias_or_object_member(
&call.callee,
&aliases.define_properties,
"defineProperties",
) || !is_binding_ref(&call.args[0].expr, target)
{
return false;
}
let Expr::Call(descs_call) = strip_parens(&call.args[1].expr) else {
return false;
};
descs_call.args.len() == 1
&& descs_call.args[0].spread.is_none()
&& is_binding_ref(&descs_call.args[0].expr, source)
&& callee_matches_alias_or_object_member(
&descs_call.callee,
&aliases.get_own_property_descriptors,
"getOwnPropertyDescriptors",
)
}
struct DefineNormalPropMarker<'a> {
target: &'a Ident,
key: &'a Ident,
value: &'a Ident,
define_property_aliases: &'a HashSet<BindingKey>,
saw_define_property: bool,
saw_fallback_assign: bool,
}
impl Visit for DefineNormalPropMarker<'_> {
fn visit_call_expr(&mut self, call: &CallExpr) {
if call.args.len() >= 2
&& call.args[0].spread.is_none()
&& call.args[1].spread.is_none()
&& is_binding_ref(&call.args[0].expr, self.target)
&& is_binding_ref(&call.args[1].expr, self.key)
&& callee_matches_alias_or_object_member(
&call.callee,
self.define_property_aliases,
"defineProperty",
)
{
self.saw_define_property = true;
}
call.visit_children_with(self);
}
fn visit_assign_expr(&mut self, assign: &swc_core::ecma::ast::AssignExpr) {
if assign.op == AssignOp::Assign
&& is_binding_ref(&assign.right, self.value)
&& assign_target_matches_computed_member(&assign.left, self.target, self.key)
{
self.saw_fallback_assign = true;
}
assign.visit_children_with(self);
}
}
struct SpreadValuesMarker<'a> {
target: &'a Ident,
source: &'a Ident,
define_normal_prop_helpers: &'a HashSet<BindingKey>,
has_own_property_aliases: &'a HashSet<BindingKey>,
saw_for_in_source: bool,
saw_has_own_call: bool,
saw_define_normal_prop_call: bool,
}
impl Visit for SpreadValuesMarker<'_> {
fn visit_for_in_stmt(&mut self, for_in: &ForInStmt) {
if expr_is_source_or_default(&for_in.right, self.source) {
self.saw_for_in_source = true;
}
for_in.visit_children_with(self);
}
fn visit_call_expr(&mut self, call: &CallExpr) {
if call.args.len() >= 2
&& call.args[0].spread.is_none()
&& call.args[1].spread.is_none()
&& is_binding_ref(&call.args[0].expr, self.target)
&& callee_matches_binding_set(&call.callee, self.define_normal_prop_helpers)
{
self.saw_define_normal_prop_call = true;
}
if call
.args
.first()
.is_some_and(|arg| arg.spread.is_none() && is_binding_ref(&arg.expr, self.source))
&& callee_is_alias_call_method(&call.callee, self.has_own_property_aliases)
{
self.saw_has_own_call = true;
}
call.visit_children_with(self);
}
}
fn expr_is_source_or_default(expr: &Expr, source: &Ident) -> bool {
if is_binding_ref(expr, source) {
return true;
}
let Expr::Bin(bin) = strip_parens(expr) else {
return false;
};
bin.op == BinaryOp::LogicalOr
&& is_binding_ref(&bin.left, source)
&& matches!(
strip_parens(&bin.right),
Expr::Assign(assign)
if assign.op == AssignOp::Assign
&& assign_target_matches_ident(&assign.left, source)
&& matches!(strip_parens(&assign.right), Expr::Object(obj) if obj.props.is_empty())
)
}
fn assign_target_matches_ident(target: &AssignTarget, ident: &Ident) -> bool {
matches!(
target,
AssignTarget::Simple(SimpleAssignTarget::Ident(binding))
if ident_matches(&binding.id, ident)
)
}
fn assign_target_matches_computed_member(target: &AssignTarget, obj: &Ident, prop: &Ident) -> bool {
let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = target else {
return false;
};
member_matches_computed_binding(member, obj, prop)
}
fn member_matches_computed_binding(member: &MemberExpr, obj: &Ident, prop: &Ident) -> bool {
if !matches!(member.obj.as_ref(), Expr::Ident(id) if ident_matches(id, obj)) {
return false;
}
let swc_core::ecma::ast::MemberProp::Computed(computed) = &member.prop else {
return false;
};
is_binding_ref(&computed.expr, prop)
}
fn callee_matches_alias_or_object_member(
callee: &Callee,
aliases: &HashSet<BindingKey>,
member_name: &str,
) -> bool {
let Callee::Expr(expr) = callee else {
return false;
};
match strip_parens(expr) {
Expr::Ident(id) => aliases.contains(&binding_key(id)),
Expr::Member(member) => {
matches!(member.obj.as_ref(), Expr::Ident(obj) if obj.sym.as_ref() == "Object")
&& member_prop_name(&member.prop, member_name)
}
_ => false,
}
}
fn callee_matches_binding_set(callee: &Callee, bindings: &HashSet<BindingKey>) -> bool {
let Callee::Expr(expr) = callee else {
return false;
};
matches!(strip_parens(expr), Expr::Ident(id) if bindings.contains(&binding_key(id)))
}
fn callee_is_alias_call_method(callee: &Callee, aliases: &HashSet<BindingKey>) -> bool {
let Callee::Expr(expr) = callee else {
return false;
};
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
member_prop_name(&member.prop, "call")
&& matches!(member.obj.as_ref(), Expr::Ident(id) if aliases.contains(&binding_key(id)))
}
fn pat_ident(pat: &Pat) -> Option<&Ident> {
let Pat::Ident(binding) = pat else {
return None;
};
Some(&binding.id)
}
fn collect_cross_module_object_spread_helpers(
module: &Module,
module_facts: &ModuleFactsMap,
current_filename: Option<&str>,
) -> HashMap<BindingKey, TranspilerHelperKind> {
let mut helpers = HashMap::new();
for item in &module.body {
let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
continue;
};
let source = str_to_atom(&import.src.value);
for specifier in &import.specifiers {
match specifier {
ImportSpecifier::Default(default) => {
if let Some(kind) = module_helper_export_kind(
module_facts,
current_filename,
&source,
"default",
) {
helpers.insert((default.local.sym.clone(), default.local.ctxt), kind);
}
}
ImportSpecifier::Named(named) => {
let imported = named
.imported
.as_ref()
.map(export_name_to_atom)
.unwrap_or_else(|| named.local.sym.clone());
if let Some(kind) = module_helper_export_kind(
module_facts,
current_filename,
&source,
imported.as_ref(),
) {
helpers.insert((named.local.sym.clone(), named.local.ctxt), kind);
}
}
ImportSpecifier::Namespace(_) => {}
}
}
}
helpers
}
fn module_helper_export_kind(
module_facts: &ModuleFactsMap,
current_filename: Option<&str>,
source: &Atom,
exported: &str,
) -> Option<TranspilerHelperKind> {
module_facts
.get_from(current_filename, source.as_ref())
.and_then(|facts| {
facts
.helper_exports
.iter()
.find(|helper| helper.exported.as_ref() == exported)
.and_then(|helper| helper_kind_to_transpiler(helper.kind))
})
}
fn helper_kind_to_transpiler(kind: HelperKind) -> Option<TranspilerHelperKind> {
match kind {
HelperKind::Extends => Some(TranspilerHelperKind::Extends),
HelperKind::ObjectSpread => Some(TranspilerHelperKind::ObjectSpread),
_ => None,
}
}
fn collect_swc_numeric_helper_namespaces(
module: &Module,
unresolved_mark: Option<Mark>,
) -> HashSet<BindingKey> {
let mut namespaces = HashSet::new();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
continue;
};
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
if decl
.init
.as_deref()
.is_some_and(|init| is_numeric_require_call(init, unresolved_mark))
{
namespaces.insert((binding.id.sym.clone(), binding.id.ctxt));
}
}
}
namespaces
}
fn is_numeric_require_call(expr: &Expr, unresolved_mark: Option<Mark>) -> bool {
let Expr::Call(call) = expr else {
return false;
};
if call.args.len() != 1 || call.args[0].spread.is_some() {
return false;
}
let Callee::Expr(callee) = &call.callee else {
return false;
};
if !matches!(callee.as_ref(), Expr::Ident(id) if id.sym.as_ref() == "require" && unresolved_mark.is_none_or(|mark| id.ctxt.outer() == mark))
{
return false;
}
matches!(call.args[0].expr.as_ref(), Expr::Lit(Lit::Num(_)))
}
fn remove_unused_numeric_helper_namespace_decls(
module: &mut Module,
namespaces: &HashSet<BindingKey>,
) {
if namespaces.is_empty() {
return;
}
let unused: HashSet<_> = namespaces
.iter()
.filter(|(sym, ctxt)| {
let ident = Ident::new(sym.clone(), DUMMY_SP, *ctxt);
!ident_used_in_module(&module.body, &ident)
})
.cloned()
.collect();
if unused.is_empty() {
return;
}
module.body.retain_mut(|item| {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
return true;
};
var.decls.retain(|decl| {
let Pat::Ident(binding) = &decl.name else {
return true;
};
!unused.contains(&(binding.id.sym.clone(), binding.id.ctxt))
});
!var.decls.is_empty()
});
}
fn ident_used_in_module(body: &[ModuleItem], target: &Ident) -> bool {
struct Finder<'a> {
target: &'a Ident,
found: bool,
}
impl Visit for Finder<'_> {
fn visit_binding_ident(&mut self, _: &swc_core::ecma::ast::BindingIdent) {}
fn visit_ident(&mut self, ident: &Ident) {
if ident.sym == self.target.sym && ident.ctxt == self.target.ctxt {
self.found = true;
}
}
}
let mut finder = Finder {
target,
found: false,
};
for item in body {
item.visit_with(&mut finder);
if finder.found {
return true;
}
}
false
}
struct SpreadReplacer<'a> {
helpers: &'a HashMap<BindingKey, TranspilerHelperKind>,
cross_module_helper_namespaces: &'a HashMap<BindingKey, HashMap<String, TranspilerHelperKind>>,
cross_module_ts_assign_namespaces: &'a HashMap<BindingKey, HashSet<String>>,
swc_numeric_helper_namespaces: &'a HashSet<BindingKey>,
tslib_namespaces: &'a HashSet<BindingKey>,
esbuild_aliases: &'a EsbuildObjectBuiltinAliases,
esbuild_define_normal_prop_helpers: &'a HashSet<BindingKey>,
}
impl VisitMut for SpreadReplacer<'_> {
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
let Expr::Call(call) = expr else { return };
let Callee::Expr(callee) = &call.callee else {
return;
};
if !self.is_object_spread_callee(callee) {
return;
}
if call.args.is_empty() {
return;
}
// Both _extends and _objectSpread2 mutate their first argument.
// Only transform when the first arg is a safe fresh object literal
// target, otherwise mutation/identity semantics are lost.
let Expr::Object(first_obj) = call.args[0].expr.as_ref() else {
return;
};
if call.args[0].spread.is_some() || !is_safe_to_inline_props(&first_obj.props) {
return;
}
// Merge all arguments into a single object expression.
// - Object literal args: flatten their properties
// - Everything else: wrap as spread element
let mut properties: Vec<PropOrSpread> = first_obj.props.clone();
for arg in &call.args[1..] {
if arg.spread.is_some() {
properties.push(PropOrSpread::Spread(SpreadElement {
dot3_token: DUMMY_SP,
expr: restore_conditional_spread_branch_order(arg.expr.clone()),
}));
continue;
}
match arg.expr.as_ref() {
Expr::Object(obj) if is_safe_to_inline_props(&obj.props) => {
properties.extend(obj.props.iter().cloned());
}
_ => {
properties.push(PropOrSpread::Spread(SpreadElement {
dot3_token: DUMMY_SP,
expr: restore_conditional_spread_branch_order(arg.expr.clone()),
}));
}
}
}
*expr = Expr::Object(ObjectLit {
span: DUMMY_SP,
props: properties,
});
}
}
/// Terser removes a leading negation by swapping conditional branches:
/// `!condition ? { value } : {}` becomes `condition ? {} : { value }`.
/// Restore the non-empty branch to the consequent when the empty branch is a
/// literal object. This preserves the condition's single evaluation.
fn restore_conditional_spread_branch_order(expr: Box<Expr>) -> Box<Expr> {
let mut cond = match *expr {
Expr::Cond(cond) => cond,
expr => return Box::new(expr),
};
if !is_empty_object_literal(&cond.cons) || is_empty_object_literal(&cond.alt) {
return Box::new(Expr::Cond(cond));
}
cond.test = negate_conditional_test(cond.test);
std::mem::swap(&mut cond.cons, &mut cond.alt);
Box::new(Expr::Cond(cond))
}
fn is_empty_object_literal(expr: &Expr) -> bool {
matches!(strip_parens(expr), Expr::Object(object) if object.props.is_empty())
}
fn negate_conditional_test(test: Box<Expr>) -> Box<Expr> {
match *test {
Expr::Unary(UnaryExpr {
op: UnaryOp::Bang,
arg,
..
}) => arg,
expr => Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: UnaryOp::Bang,
arg: Box::new(expr),
})),
}
}
impl SpreadReplacer<'_> {
fn is_object_spread_callee(&self, callee: &Expr) -> bool {
match strip_parens(callee) {
Expr::Ident(id) => {
let key = (id.sym.clone(), id.ctxt);
matches!(
self.helpers.get(&key),
Some(TranspilerHelperKind::Extends | TranspilerHelperKind::ObjectSpread)
)
}
Expr::Member(_) => {
matches!(
tslib_member_helper_kind(callee, self.tslib_namespaces),
Some(TranspilerHelperKind::Extends | TranspilerHelperKind::ObjectSpread)
) || matches!(
cross_module_member_helper_kind(callee, self.cross_module_helper_namespaces),
Some(TranspilerHelperKind::Extends | TranspilerHelperKind::ObjectSpread)
) || cross_module_ts_member_helper(callee, self.cross_module_ts_assign_namespaces)
|| is_swc_numeric_object_spread_member(
callee,
self.swc_numeric_helper_namespaces,
)
}
expr => is_inline_object_spread_helper(
expr,
self.esbuild_aliases,
self.esbuild_define_normal_prop_helpers,
),
}
}
}
fn is_swc_numeric_object_spread_member(expr: &Expr, namespaces: &HashSet<BindingKey>) -> bool {
let Expr::Member(member) = expr else {
return false;
};
let Expr::Ident(obj) = member.obj.as_ref() else {
return false;
};
namespaces.contains(&binding_key(obj)) && static_member_prop_name(&member.prop) == Some("pi")
}
fn has_inline_object_spread_call(
module: &Module,
esbuild_aliases: &EsbuildObjectBuiltinAliases,
esbuild_define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
struct Finder<'a> {
esbuild_aliases: &'a EsbuildObjectBuiltinAliases,
esbuild_define_normal_prop_helpers: &'a HashSet<BindingKey>,
found: bool,
}
impl Visit for Finder<'_> {
fn visit_call_expr(&mut self, call: &CallExpr) {
if self.found {
return;
}
if let Callee::Expr(callee) = &call.callee {
if is_inline_object_spread_helper(
callee.as_ref(),
self.esbuild_aliases,
self.esbuild_define_normal_prop_helpers,
) {
self.found = true;
return;
}
}
call.visit_children_with(self);
}
}
let mut finder = Finder {
esbuild_aliases,
esbuild_define_normal_prop_helpers,
found: false,
};
module.visit_with(&mut finder);
finder.found
}
fn is_inline_object_spread_helper(
expr: &Expr,
esbuild_aliases: &EsbuildObjectBuiltinAliases,
esbuild_define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
match strip_parens(expr) {
Expr::Fn(fn_expr) => {
function_matches_inline_object_spread(
&fn_expr.function,
esbuild_aliases,
esbuild_define_normal_prop_helpers,
) || function_matches_arguments_object_spread(&fn_expr.function)
}
Expr::Arrow(arrow) => {
let Some((target, source)) = arrow_param_pair(&arrow.params) else {
return false;
};
match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => {
block_matches_inline_object_spread(
&block.stmts,
target,
source,
esbuild_define_normal_prop_helpers,
) || block_single_return_expr(&block.stmts).is_some_and(|expr| {
spread_props_expr_matches(
expr,
target,
source,
esbuild_aliases,
esbuild_define_normal_prop_helpers,
)
})
}
BlockStmtOrExpr::Expr(expr) => expr_matches_inline_object_spread(
expr,
target,
source,
esbuild_aliases,
esbuild_define_normal_prop_helpers,
),
}
}
_ => false,
}
}
fn function_matches_inline_object_spread(
function: &Function,
esbuild_aliases: &EsbuildObjectBuiltinAliases,
esbuild_define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
let Some(body) = &function.body else {
return false;
};
let params: Vec<_> = function.params.iter().map(|param| ¶m.pat).collect();
let Some((target, source)) = pat_pair(¶ms) else {
return false;
};
block_matches_inline_object_spread(
&body.stmts,
target,
source,
esbuild_define_normal_prop_helpers,
) || block_single_return_expr(&body.stmts).is_some_and(|expr| {
spread_props_expr_matches(
expr,
target,
source,
esbuild_aliases,
esbuild_define_normal_prop_helpers,
)
})
}
fn block_single_return_expr(stmts: &[Stmt]) -> Option<&Expr> {
let [Stmt::Return(ReturnStmt { arg: Some(arg), .. })] = stmts else {
return None;
};
Some(arg)
}
fn function_matches_arguments_object_spread(function: &Function) -> bool {
let Some(body) = &function.body else {
return false;
};
let [param] = function.params.as_slice() else {
return false;
};
let Pat::Ident(target) = ¶m.pat else {
return false;
};
let [copy_stmt, Stmt::Return(ret)] = body.stmts.as_slice() else {
return false;
};
if !ret
.arg
.as_deref()
.is_some_and(|arg| is_binding_ref(arg, &target.id))
{
return false;
}
if !matches!(copy_stmt, Stmt::For(_)) {
return false;
}
let mut marker = ArgumentsSpreadMarker::new(&target.id);
copy_stmt.visit_with(&mut marker);
marker.is_match()
}
struct ArgumentsSpreadMarker<'a> {
target: &'a Ident,
saw_arguments_ref: bool,
saw_target_write: bool,
saw_unsafe_target_write: bool,
saw_object_define_property: bool,
saw_object_get_own_property_descriptor: bool,
}
impl<'a> ArgumentsSpreadMarker<'a> {
fn new(target: &'a Ident) -> Self {
Self {
target,
saw_arguments_ref: false,
saw_target_write: false,
saw_unsafe_target_write: false,
saw_object_define_property: false,
saw_object_get_own_property_descriptor: false,
}
}
fn is_match(&self) -> bool {
self.saw_arguments_ref
&& self.saw_target_write
&& !self.saw_unsafe_target_write
&& self.saw_object_define_property
&& self.saw_object_get_own_property_descriptor
}
}
impl Visit for ArgumentsSpreadMarker<'_> {
fn visit_assign_expr(&mut self, assign: &swc_core::ecma::ast::AssignExpr) {
if let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left {
if matches!(member.obj.as_ref(), Expr::Ident(ident) if ident_matches(ident, self.target))
{
if matches!(member.prop, MemberProp::Computed(_)) {
self.saw_target_write = true;
} else {
self.saw_unsafe_target_write = true;
}
}
}
assign.visit_children_with(self);
}
fn visit_call_expr(&mut self, call: &CallExpr) {
if let Callee::Expr(callee) = &call.callee {
if let Expr::Member(member) = strip_parens(callee.as_ref()) {
if let Expr::Ident(obj) = member.obj.as_ref() {
if obj.sym.as_ref() == "Object" {
match static_member_prop_name(&member.prop) {
Some("defineProperty" | "defineProperties") => {
self.saw_object_define_property = true;
if call
.args
.first()
.is_some_and(|arg| is_binding_ref(&arg.expr, self.target))
{
self.saw_target_write = true;
}
}
Some("getOwnPropertyDescriptor" | "getOwnPropertyDescriptors") => {
self.saw_object_get_own_property_descriptor = true;
}
_ => {}
}
}
}
}
}
call.visit_children_with(self);
}
fn visit_ident(&mut self, ident: &Ident) {
if ident.sym.as_ref() == "arguments" {
self.saw_arguments_ref = true;
}
}
}
fn block_matches_inline_object_spread(
stmts: &[Stmt],
target: &Ident,
source: &Ident,
esbuild_define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
if !matches!(
stmts.last(),
Some(Stmt::Return(ret)) if ret.arg.as_deref().is_some_and(|arg| is_binding_ref(arg, target))
) {
return false;
}
let mut marker = InlineSpreadMarker::new(target, source, esbuild_define_normal_prop_helpers);
stmts.visit_with(&mut marker);
marker.is_match()
}
fn expr_matches_inline_object_spread(
expr: &Expr,
target: &Ident,
source: &Ident,
esbuild_aliases: &EsbuildObjectBuiltinAliases,
esbuild_define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
let mut marker = InlineSpreadMarker::new(target, source, esbuild_define_normal_prop_helpers);
expr.visit_with(&mut marker);
marker.is_match()
|| spread_props_expr_matches(
expr,
target,
source,
esbuild_aliases,
esbuild_define_normal_prop_helpers,
)
}
fn arrow_param_pair(params: &[Pat]) -> Option<(&Ident, &Ident)> {
let refs: Vec<_> = params.iter().collect();
pat_pair(&refs)
}
fn pat_pair<'a>(params: &[&'a Pat]) -> Option<(&'a Ident, &'a Ident)> {
let [Pat::Ident(target), Pat::Ident(source)] = params else {
return None;
};
Some((&target.id, &source.id))
}
struct InlineSpreadMarker<'a> {
target: &'a Ident,
source: &'a Ident,
esbuild_define_normal_prop_helpers: &'a HashSet<BindingKey>,
saw_generated_spread_helper: bool,
saw_target_helper_arg: bool,
saw_source_ref: bool,
}
impl<'a> InlineSpreadMarker<'a> {
fn new(
target: &'a Ident,
source: &'a Ident,
esbuild_define_normal_prop_helpers: &'a HashSet<BindingKey>,
) -> Self {
Self {
target,
source,
esbuild_define_normal_prop_helpers,
saw_generated_spread_helper: false,
saw_target_helper_arg: false,
saw_source_ref: false,
}
}
fn is_match(&self) -> bool {
self.saw_generated_spread_helper && self.saw_target_helper_arg && self.saw_source_ref
}
}
impl Visit for InlineSpreadMarker<'_> {
fn visit_ident(&mut self, ident: &Ident) {
if ident_matches(ident, self.source) {
self.saw_source_ref = true;
}
}
fn visit_call_expr(&mut self, call: &CallExpr) {
if is_generated_spread_helper_callee(&call.callee, self.esbuild_define_normal_prop_helpers)
{
self.saw_generated_spread_helper = true;
if call
.args
.first()
.is_some_and(|arg| arg.spread.is_none() && is_binding_ref(&arg.expr, self.target))
{
self.saw_target_helper_arg = true;
}
}
call.visit_children_with(self);
}
}
fn is_generated_spread_helper_callee(
callee: &Callee,
esbuild_define_normal_prop_helpers: &HashSet<BindingKey>,
) -> bool {
let Callee::Expr(expr) = callee else {
return false;
};
match strip_parens(expr) {
Expr::Ident(id) => {
matches!(id.sym.as_ref(), "__defNormalProp" | "__defProps")
|| esbuild_define_normal_prop_helpers.contains(&binding_key(id))
}
Expr::Member(member) => match &member.prop {
swc_core::ecma::ast::MemberProp::Ident(prop) => {
matches!(prop.sym.as_ref(), "defineProperty" | "defineProperties")
}
swc_core::ecma::ast::MemberProp::PrivateName(_)
| swc_core::ecma::ast::MemberProp::Computed(_) => false,
},
_ => false,
}
}
fn is_binding_ref(expr: &Expr, binding: &Ident) -> bool {
matches!(strip_parens(expr), Expr::Ident(id) if ident_matches(id, binding))
}
fn ident_matches(left: &Ident, right: &Ident) -> bool {
left.sym == right.sym && left.ctxt == right.ctxt
}
fn is_safe_to_inline_props(props: &[PropOrSpread]) -> bool {
props.iter().all(is_safe_to_inline_prop)
}
fn is_safe_to_inline_prop(prop: &PropOrSpread) -> bool {
match prop {
PropOrSpread::Spread(_) => true,
PropOrSpread::Prop(prop) => match prop.as_ref() {
Prop::Shorthand(ident) => ident.sym != "__proto__",
Prop::KeyValue(kv) => !is_bare_proto_name(&kv.key),
Prop::Assign(assign) => assign.key.sym != "__proto__",
Prop::Getter(_) | Prop::Setter(_) | Prop::Method(_) => false,
},
}
}
fn is_bare_proto_name(name: &PropName) -> bool {
match name {
PropName::Ident(ident) => ident.sym == "__proto__",
PropName::Str(value) => value.value == "__proto__",
PropName::Num(_) | PropName::BigInt(_) | PropName::Computed(_) => false,
}
}
fn export_name_to_atom(name: &swc_core::ecma::ast::ModuleExportName) -> Atom {
match name {
swc_core::ecma::ast::ModuleExportName::Ident(id) => id.sym.clone(),
swc_core::ecma::ast::ModuleExportName::Str(s) => str_to_atom(&s.value),
}
}
fn str_to_atom(value: &swc_core::atoms::Wtf8Atom) -> Atom {
Atom::from(value.as_str().unwrap_or(""))
}