crates/core/src/rules/un_define_property.rs
GitHub//! Detect and unwrap the Babel `_defineProperty` helper when it is inlined as
//! a local function decl.
//!
//! Shape matched:
//!
//! ```js
//! function _defineProperty(e, t, n) {
//! if (t in e) {
//! Object.defineProperty(e, t, {
//! value: n,
//! enumerable: true,
//! configurable: true,
//! writable: true,
//! });
//! } else {
//! e[t] = n;
//! }
//! return e;
//! }
//! ```
//!
//! Standalone calls are rewritten to assignments when the helper's return
//! value is discarded. At standard and above, expression-position calls whose
//! target is exactly `{}` are restored to `{ [key]: value }`; other expression
//! targets stay intact because rewriting them would lose `return e` semantics.
//!
//! If all references to the helper are call sites we rewrote, the helper
//! function declaration is dropped. Exported helpers are always preserved.
use std::collections::HashSet;
use swc_core::common::DUMMY_SP;
use swc_core::ecma::ast::{
AssignExpr, AssignOp, AssignTarget, Callee, ComputedPropName, Expr, ExprStmt, KeyValueProp,
MemberExpr, MemberProp, Module, ObjectLit, Prop, PropName, PropOrSpread, SimpleAssignTarget,
Stmt,
};
use swc_core::ecma::visit::{VisitMut, VisitMutWith};
use super::helper_matcher::{binding_key, BindingKey};
use super::transpiler_helper_utils::{LocalHelperContext, TranspilerHelperKind};
use super::RewriteLevel;
pub struct UnDefineProperty;
impl UnDefineProperty {
pub(crate) fn run_with_helpers(
module: &mut Module,
local_helpers: &LocalHelperContext,
rewrite_level: RewriteLevel,
) {
run_un_define_property(module, local_helpers, rewrite_level);
}
}
impl VisitMut for UnDefineProperty {
fn visit_mut_module(&mut self, module: &mut Module) {
let local_helpers = LocalHelperContext::collect(module);
run_un_define_property(module, &local_helpers, RewriteLevel::Standard);
}
}
fn run_un_define_property(
module: &mut Module,
local_helpers: &LocalHelperContext,
rewrite_level: RewriteLevel,
) {
let helper_map = local_helpers.helpers_of_kind(TranspilerHelperKind::DefineProperty);
let helpers: HelperSet = helper_map.keys().cloned().collect();
if helpers.is_empty() {
return;
}
let mut rewriter = CallSiteRewriter {
helpers: &helpers,
rewrite_level,
rewrote_any: false,
};
module.visit_mut_with(&mut rewriter);
if rewriter.rewrote_any {
local_helpers.remove_helpers_with_dependencies(module, helper_map);
}
}
/// Helper declaration bindings, keyed by resolver binding identity.
type HelperSet = HashSet<BindingKey>;
struct CallSiteRewriter<'a> {
helpers: &'a HelperSet,
rewrite_level: RewriteLevel,
rewrote_any: bool,
}
impl CallSiteRewriter<'_> {
fn try_rewrite_expr_stmt(&mut self, stmt: &mut Stmt) -> bool {
let Stmt::Expr(ExprStmt { expr, span }) = stmt else {
return false;
};
let Expr::Call(call) = expr.as_ref() else {
return false;
};
let Callee::Expr(callee_expr) = &call.callee else {
return false;
};
let Expr::Ident(callee_ident) = callee_expr.as_ref() else {
return false;
};
if !self.helpers.contains(&binding_key(callee_ident)) {
return false;
}
if call.args.len() != 3 {
return false;
}
// No spread args allowed — we need all three positionally.
if call.args.iter().any(|a| a.spread.is_some()) {
return false;
}
let obj = call.args[0].expr.clone();
let key = call.args[1].expr.clone();
let value = call.args[2].expr.clone();
// Build obj[key] = value
let new_expr = Expr::Assign(AssignExpr {
span: DUMMY_SP,
op: AssignOp::Assign,
left: AssignTarget::Simple(SimpleAssignTarget::Member(MemberExpr {
span: DUMMY_SP,
obj,
prop: MemberProp::Computed(ComputedPropName {
span: DUMMY_SP,
expr: key,
}),
})),
right: value,
});
*stmt = Stmt::Expr(ExprStmt {
span: *span,
expr: Box::new(new_expr),
});
self.rewrote_any = true;
true
}
fn try_rewrite_fresh_object_call(&mut self, expr: &mut Expr) -> bool {
if self.rewrite_level < RewriteLevel::Standard {
return false;
}
let Expr::Call(call) = expr else {
return false;
};
let Callee::Expr(callee_expr) = &call.callee else {
return false;
};
let Expr::Ident(callee_ident) = callee_expr.as_ref() else {
return false;
};
if !self.helpers.contains(&binding_key(callee_ident))
|| call.args.len() != 3
|| call.args.iter().any(|arg| arg.spread.is_some())
{
return false;
}
let Expr::Object(target) = call.args[0].expr.as_ref() else {
return false;
};
if !target.props.is_empty() {
return false;
}
let key = call.args[1].expr.clone();
let value = call.args[2].expr.clone();
// Assumption: effect_free_property_key_coercion. Babel/SWC evaluate
// the value argument before their helper coerces `key`; a computed
// property coerces `key` first. The known producer shape uses ordinary
// primitive property keys, but minimal mode preserves the exact order.
*expr = Expr::Object(ObjectLit {
span: DUMMY_SP,
props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Computed(ComputedPropName {
span: DUMMY_SP,
expr: key,
}),
value,
})))],
});
self.rewrote_any = true;
true
}
}
impl VisitMut for CallSiteRewriter<'_> {
fn visit_mut_stmt(&mut self, stmt: &mut Stmt) {
self.try_rewrite_expr_stmt(stmt);
stmt.visit_mut_children_with(self);
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
self.try_rewrite_fresh_object_call(expr);
}
}