crates/core/src/rules/un_regenerator.rs
GitHubuse std::collections::{HashMap, HashSet};
use swc_core::atoms::Atom;
use swc_core::common::{Mark, Span, Spanned, DUMMY_SP};
use swc_core::ecma::ast::{
ArrayLit, ArrowExpr, AssignExpr, AssignOp, AssignTarget, AwaitExpr, BlockStmt, BlockStmtOrExpr,
CallExpr, Callee, Decl, Expr, ExprOrSpread, ExprStmt, FnDecl, FnExpr, Function, Ident,
ImportSpecifier, Lit, MemberExpr, MemberProp, Module, ModuleDecl, ModuleItem, Number,
ObjectLit, Param, ParenExpr, Pat, Prop, PropName, PropOrSpread, ReturnStmt, SimpleAssignTarget,
Stmt, SwitchCase, VarDeclarator, WhileStmt, YieldExpr,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};
use crate::facts::{HelperKind, ModuleFactsMap};
use super::helper_matcher::{
binding_key, count_binding_refs, member_prop_name, remove_fn_decls_by_binding,
remove_var_declarators_by_binding,
};
use super::state_machine::{
invert_condition, stmts_contain_state_opcode_return, ForwardJumpJoin, IndexLoopContinueMode,
OpcodeReturnScan, StateMachineProgram,
};
use super::transpiler_helper_utils::{
BindingKey, LocalHelperContext, TranspilerHelperKind, TsHelperKind,
};
use super::un_async_await::try_transform_ts_generator_body;
use crate::js_names::is_likely_generated_alias;
use crate::utils::paren::strip_parens;
pub struct UnRegenerator<'a> {
unresolved_mark: Mark,
module_facts: Option<&'a ModuleFactsMap>,
current_filename: Option<&'a str>,
}
impl UnRegenerator<'_> {
pub fn new(unresolved_mark: Mark) -> Self {
Self {
unresolved_mark,
module_facts: None,
current_filename: None,
}
}
}
impl<'a> UnRegenerator<'a> {
pub fn new_with_facts(unresolved_mark: Mark, module_facts: &'a ModuleFactsMap) -> Self {
Self {
unresolved_mark,
module_facts: Some(module_facts),
current_filename: None,
}
}
pub(crate) fn run_with_helpers(
module: &mut Module,
unresolved_mark: Mark,
module_facts: Option<&ModuleFactsMap>,
current_filename: Option<&str>,
local_helpers: &LocalHelperContext,
) {
run_un_regenerator(
module,
unresolved_mark,
module_facts,
current_filename,
local_helpers,
);
}
}
impl VisitMut for UnRegenerator<'_> {
fn visit_mut_module(&mut self, module: &mut Module) {
let local_helpers = LocalHelperContext::collect_with_mark(module, self.unresolved_mark);
run_un_regenerator(
module,
self.unresolved_mark,
self.module_facts,
self.current_filename,
&local_helpers,
);
}
}
fn run_un_regenerator(
module: &mut Module,
unresolved_mark: Mark,
module_facts: Option<&ModuleFactsMap>,
current_filename: Option<&str>,
local_helpers: &LocalHelperContext,
) {
// Phase 1: Detect _asyncToGenerator helper bindings (scope-aware)
let helpers = local_helpers.helpers();
let mut async_to_gen_bindings: Vec<BindingKey> = helpers
.iter()
.filter(|(_, kind)| **kind == TranspilerHelperKind::AsyncToGenerator)
.map(|((sym, ctxt), _)| (sym.clone(), *ctxt))
.collect();
let mut async_to_gen_default_members = Vec::new();
if let Some(module_facts) = module_facts {
let imported_helpers = collect_cross_module_async_helpers(
module,
module_facts,
current_filename,
unresolved_mark,
);
async_to_gen_bindings.extend(imported_helpers.direct);
async_to_gen_default_members.extend(imported_helpers.default_members);
}
let async_to_gen_callees = AsyncToGenCallees {
direct: &async_to_gen_bindings,
default_members: &async_to_gen_default_members,
};
let generator_helpers: Vec<BindingKey> = local_helpers
.ts_helpers_of_kind(TsHelperKind::Generator)
.into_iter()
.collect();
let regenerator_runtime_helpers = collect_regenerator_runtime_helpers(module);
let esbuild_async_helpers = collect_esbuild_async_helpers(module, unresolved_mark);
let esbuild_yield_star_helpers = collect_esbuild_yield_star_helpers(module);
// Phase 2: Transform functions containing regeneratorRuntime.wrap()
// and _asyncToGenerator() calls. Track consumed mark bindings.
let mut consumed_marks: Vec<BindingKey> = Vec::new();
transform_babel_async_trampolines(
module,
&async_to_gen_callees,
&generator_helpers,
&mut consumed_marks,
);
let mut transformer = FunctionTransformer {
unresolved_mark,
async_to_gen_callees: &async_to_gen_callees,
generator_helpers: &generator_helpers,
esbuild_async_helpers: &esbuild_async_helpers,
esbuild_yield_star_helpers: &esbuild_yield_star_helpers,
consumed_marks: &mut consumed_marks,
};
module.visit_mut_with(&mut transformer);
collapse_async_trampoline_iifes(module);
collapse_async_trampoline_sequences(module);
collapse_async_trampoline_assignments(module);
// Post-pass: strip the `_regeneratorValues` iterator wrapper from recovered
// `yield*` delegations. Decode already handles the canonical name, but
// top-level mangling renames the helper, so match the detected binding too.
let regenerator_values_helpers = collect_regenerator_values_helpers(module);
if !regenerator_values_helpers.is_empty() {
let mut unwrapper = RegeneratorValuesUnwrapper {
helpers: ®enerator_values_helpers,
};
module.visit_mut_with(&mut unwrapper);
remove_unused_helper_decls(module, ®enerator_values_helpers);
}
// Phase 3: Remove only the mark declarations that were consumed
remove_consumed_mark_declarations(module, &consumed_marks);
// Phase 4: Remove _asyncToGenerator helper if no longer referenced
if !async_to_gen_bindings.is_empty() {
let roots: HashMap<BindingKey, TranspilerHelperKind> = helpers
.iter()
.filter(|(key, kind)| {
**kind == TranspilerHelperKind::AsyncToGenerator
&& async_to_gen_bindings.contains(key)
})
.map(|(key, kind)| (key.clone(), *kind))
.collect();
local_helpers.remove_helpers_with_dependencies(module, roots);
}
if !regenerator_runtime_helpers.is_empty() {
local_helpers.remove_helpers_with_dependencies(module, regenerator_runtime_helpers);
}
remove_unused_helper_decls(module, &esbuild_async_helpers);
remove_unused_helper_decls(module, &esbuild_yield_star_helpers);
}
struct AsyncToGenCallees<'a> {
direct: &'a [BindingKey],
default_members: &'a [BindingKey],
}
#[derive(Default)]
struct CrossModuleAsyncHelpers {
direct: Vec<BindingKey>,
default_members: Vec<BindingKey>,
}
fn collect_cross_module_async_helpers(
module: &Module,
module_facts: &ModuleFactsMap,
current_filename: Option<&str>,
unresolved_mark: Mark,
) -> CrossModuleAsyncHelpers {
let mut helpers = CrossModuleAsyncHelpers::default();
for item in &module.body {
match item {
ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {
if !module_exports_helper(
module_facts,
current_filename,
&str_to_atom(&import.src.value),
"default",
HelperKind::AsyncToGenerator,
) {
continue;
}
for specifier in &import.specifiers {
match specifier {
ImportSpecifier::Default(default) => {
helpers
.direct
.push((default.local.sym.clone(), default.local.ctxt));
}
ImportSpecifier::Namespace(namespace) => {
helpers
.default_members
.push((namespace.local.sym.clone(), namespace.local.ctxt));
}
ImportSpecifier::Named(named)
if named
.imported
.as_ref()
.is_some_and(|imported| export_name_is(imported, "default")) =>
{
helpers
.direct
.push((named.local.sym.clone(), named.local.ctxt));
}
_ => {}
}
}
}
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
let Some(init) = &decl.init else {
continue;
};
let Some(source) = require_source_from_interop_init(init, unresolved_mark)
else {
continue;
};
if module_exports_helper(
module_facts,
current_filename,
&source,
"default",
HelperKind::AsyncToGenerator,
) {
helpers
.default_members
.push((binding.id.sym.clone(), binding.id.ctxt));
}
}
}
_ => {}
}
}
helpers
}
fn module_exports_helper(
module_facts: &ModuleFactsMap,
current_filename: Option<&str>,
source: &Atom,
exported: &str,
kind: HelperKind,
) -> bool {
module_facts
.get_from(current_filename, source.as_ref())
.is_some_and(|facts| {
facts
.helper_exports
.iter()
.any(|helper| helper.exported.as_ref() == exported && helper.kind == kind)
})
}
fn collect_regenerator_runtime_helpers(
module: &Module,
) -> HashMap<BindingKey, TranspilerHelperKind> {
let mut helpers = HashMap::new();
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl)))
if is_regenerator_runtime_helper_fn(&fn_decl.function) =>
{
helpers.insert(
(fn_decl.ident.sym.clone(), fn_decl.ident.ctxt),
TranspilerHelperKind::HelperDependency,
);
}
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
let Some(init) = &decl.init else {
continue;
};
if is_regenerator_runtime_helper_expr(init) {
helpers.insert(
(binding.id.sym.clone(), binding.id.ctxt),
TranspilerHelperKind::HelperDependency,
);
}
}
}
_ => {}
}
}
helpers
}
fn is_regenerator_runtime_helper_expr(expr: &Expr) -> bool {
match strip_parens(expr) {
Expr::Fn(fn_expr) => is_regenerator_runtime_helper_fn(&fn_expr.function),
Expr::Arrow(arrow) => is_regenerator_runtime_helper_arrow(arrow),
_ => false,
}
}
fn is_regenerator_runtime_helper_fn(function: &Function) -> bool {
if !function.params.is_empty() {
return false;
}
let Some(body) = &function.body else {
return false;
};
let mut finder = RegeneratorRuntimeHelperFinder::default();
body.visit_with(&mut finder);
finder.is_match()
}
fn is_regenerator_runtime_helper_arrow(arrow: &ArrowExpr) -> bool {
if !arrow.params.is_empty() {
return false;
}
let BlockStmtOrExpr::BlockStmt(body) = arrow.body.as_ref() else {
return false;
};
let mut finder = RegeneratorRuntimeHelperFinder::default();
body.visit_with(&mut finder);
finder.is_match()
}
#[derive(Default)]
struct RegeneratorRuntimeHelperFinder {
found_runtime_exports: bool,
found_invoke_marker: bool,
found_generator_marker: bool,
}
impl RegeneratorRuntimeHelperFinder {
fn is_match(&self) -> bool {
self.found_runtime_exports && (self.found_invoke_marker || self.found_generator_marker)
}
}
impl Visit for RegeneratorRuntimeHelperFinder {
fn visit_object_lit(&mut self, obj: &ObjectLit) {
if object_lit_has_regenerator_runtime_exports(obj) {
self.found_runtime_exports = true;
}
obj.visit_children_with(self);
}
fn visit_lit(&mut self, lit: &Lit) {
let Lit::Str(str_lit) = lit else {
return;
};
match str_lit.value.as_str() {
Some("_invoke") => self.found_invoke_marker = true,
Some("GeneratorFunction") | Some("Generator is already running") => {
self.found_generator_marker = true;
}
_ => {}
}
}
}
fn object_lit_has_regenerator_runtime_exports(obj: &ObjectLit) -> bool {
let mut has_wrap = false;
let mut has_mark = false;
for prop in &obj.props {
let PropOrSpread::Prop(prop) = prop else {
continue;
};
let name = match prop.as_ref() {
Prop::KeyValue(kv) => prop_name_static(&kv.key),
Prop::Method(method) => prop_name_static(&method.key),
Prop::Getter(getter) => prop_name_static(&getter.key),
Prop::Setter(setter) => prop_name_static(&setter.key),
Prop::Shorthand(ident) => Some(ident.sym.as_ref()),
Prop::Assign(assign) => Some(assign.key.sym.as_ref()),
};
match name {
Some("wrap" | "w") => has_wrap = true,
Some("mark" | "m") => has_mark = true,
_ => {}
}
}
has_wrap && has_mark
}
fn prop_name_static(name: &PropName) -> Option<&str> {
match name {
PropName::Ident(ident) => Some(ident.sym.as_ref()),
PropName::Str(str_lit) => str_lit.value.as_str(),
PropName::Computed(computed) => match computed.expr.as_ref() {
Expr::Lit(Lit::Str(str_lit)) => str_lit.value.as_str(),
_ => None,
},
PropName::Num(_) | PropName::BigInt(_) => None,
}
}
fn require_source_from_interop_init(expr: &Expr, unresolved_mark: Mark) -> Option<Atom> {
if let Some(source) = require_source(expr, unresolved_mark) {
return Some(source);
}
let Expr::Call(call) = expr else {
return None;
};
if call.args.len() != 1 || call.args[0].spread.is_some() {
return None;
}
require_source(&call.args[0].expr, unresolved_mark)
}
fn require_source(expr: &Expr, unresolved_mark: Mark) -> Option<Atom> {
let Expr::Call(call) = expr else {
return None;
};
if call.args.len() != 1 || call.args[0].spread.is_some() {
return None;
}
let callee = call.callee.as_expr()?;
if !matches!(callee.as_ref(), Expr::Ident(id) if id.sym.as_ref() == "require" && id.ctxt.outer() == unresolved_mark)
{
return None;
}
let Expr::Lit(Lit::Str(source)) = call.args[0].expr.as_ref() else {
return None;
};
Some(str_to_atom(&source.value))
}
fn transform_babel_async_trampolines(
module: &mut Module,
async_to_gen_callees: &AsyncToGenCallees,
generator_helpers: &[BindingKey],
consumed_marks: &mut Vec<BindingKey>,
) {
let mut index = 0;
while index + 1 < module.body.len() {
let Some((public_name, private_key)) = extract_public_trampoline_fn(&module.body[index])
else {
index += 1;
continue;
};
if binding_used_outside_pair(&module.body, index, index + 1, &private_key) {
index += 1;
continue;
}
let Some((params, mut stmts, mark_key)) = extract_private_trampoline_body(
&module.body[index + 1],
&private_key,
async_to_gen_callees,
generator_helpers,
) else {
index += 1;
continue;
};
let Some(public_decl) = public_fn_decl_from_module_item_mut(&mut module.body[index]) else {
index += 1;
continue;
};
if public_decl.ident.sym != public_name.0 || public_decl.ident.ctxt != public_name.1 {
index += 1;
continue;
}
replace_yield_with_await(&mut stmts);
public_decl.function.params = params;
public_decl.function.body = Some(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts,
});
public_decl.function.is_async = true;
public_decl.function.is_generator = false;
if let Some(mark_key) = mark_key {
consumed_marks.push(mark_key);
}
module.body.remove(index + 1);
index += 1;
}
}
fn extract_public_trampoline_fn(item: &ModuleItem) -> Option<(BindingKey, BindingKey)> {
let fn_decl = public_fn_decl_from_module_item(item)?;
let private_ident = private_apply_return_ident(fn_decl)?;
Some((
(fn_decl.ident.sym.clone(), fn_decl.ident.ctxt),
(private_ident.sym.clone(), private_ident.ctxt),
))
}
fn public_fn_decl_from_module_item(item: &ModuleItem) -> Option<&FnDecl> {
match item {
ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) => Some(fn_decl),
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => match &export.decl {
Decl::Fn(fn_decl) => Some(fn_decl),
_ => None,
},
_ => None,
}
}
fn public_fn_decl_from_module_item_mut(item: &mut ModuleItem) -> Option<&mut FnDecl> {
match item {
ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) => Some(fn_decl),
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => match &mut export.decl {
Decl::Fn(fn_decl) => Some(fn_decl),
_ => None,
},
_ => None,
}
}
fn private_apply_return_ident(fn_decl: &FnDecl) -> Option<Ident> {
let body = fn_decl.function.body.as_ref()?;
if body.stmts.len() != 1 {
return None;
}
let Stmt::Return(ret) = &body.stmts[0] else {
return None;
};
let arg = ret.arg.as_deref()?;
extract_apply_this_arguments_callee(arg)
}
fn extract_apply_this_arguments_callee(expr: &Expr) -> Option<Ident> {
let Expr::Call(call) = expr else {
return None;
};
if call.args.len() != 2 {
return None;
}
if !matches!(call.args[0].expr.as_ref(), Expr::This(_)) {
return None;
}
if !matches!(call.args[1].expr.as_ref(), Expr::Ident(id) if id.sym.as_ref() == "arguments") {
return None;
}
let callee = call.callee.as_expr()?;
let Expr::Member(apply_member) = callee.as_ref() else {
return None;
};
if !member_prop_name(&apply_member.prop, "apply") {
return None;
}
let Expr::Ident(id) = apply_member.obj.as_ref() else {
return None;
};
Some(id.clone())
}
fn extract_private_trampoline_body(
item: &ModuleItem,
private_key: &BindingKey,
async_to_gen_callees: &AsyncToGenCallees,
generator_helpers: &[BindingKey],
) -> Option<(Vec<Param>, Vec<Stmt>, Option<BindingKey>)> {
let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) = item else {
return None;
};
if fn_decl.ident.sym != private_key.0 || fn_decl.ident.ctxt != private_key.1 {
return None;
}
let body = fn_decl.function.body.as_ref()?;
let gen_arg = match body.stmts.as_slice() {
[assign_stmt, return_stmt]
if apply_return_ident_from_stmt(return_stmt)
.is_some_and(|id| id.sym == private_key.0 && id.ctxt == private_key.1) =>
{
extract_async_assignment_arg(assign_stmt, private_key, async_to_gen_callees)?
}
[return_stmt] => extract_async_assignment_arg_from_returned_apply(
return_stmt,
private_key,
async_to_gen_callees,
)?,
_ => return None,
};
extract_async_to_gen_body_with_params(gen_arg, generator_helpers)
}
fn apply_return_ident_from_stmt(stmt: &Stmt) -> Option<Ident> {
let Stmt::Return(ret) = stmt else {
return None;
};
let arg = ret.arg.as_deref()?;
extract_apply_this_arguments_callee(arg)
}
fn extract_async_assignment_arg(
stmt: &Stmt,
private_key: &BindingKey,
async_to_gen_callees: &AsyncToGenCallees,
) -> Option<Expr> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(left)) = &assign.left else {
return None;
};
if left.id.sym != private_key.0 || left.id.ctxt != private_key.1 {
return None;
}
let Expr::Call(call) = assign.right.as_ref() else {
return None;
};
if call.args.len() != 1 {
return None;
}
let callee = call.callee.as_expr()?;
if !is_async_to_gen_callee(callee, async_to_gen_callees) {
return None;
}
Some(*call.args[0].expr.clone())
}
fn extract_async_assignment_arg_from_returned_apply(
stmt: &Stmt,
private_key: &BindingKey,
async_to_gen_callees: &AsyncToGenCallees,
) -> Option<Expr> {
let Stmt::Return(ret) = stmt else {
return None;
};
let Expr::Call(apply_call) = ret.arg.as_deref()? else {
return None;
};
if apply_call.args.len() != 2 {
return None;
}
if !matches!(apply_call.args[0].expr.as_ref(), Expr::This(_)) {
return None;
}
if !matches!(apply_call.args[1].expr.as_ref(), Expr::Ident(id) if id.sym.as_ref() == "arguments")
{
return None;
}
let apply_callee = apply_call.callee.as_expr()?;
let Expr::Member(apply_member) = apply_callee.as_ref() else {
return None;
};
if !member_prop_name(&apply_member.prop, "apply") {
return None;
}
let Expr::Assign(assign) = strip_parens(&apply_member.obj) else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(left)) = &assign.left else {
return None;
};
if left.id.sym != private_key.0 || left.id.ctxt != private_key.1 {
return None;
}
let Expr::Call(helper_call) = assign.right.as_ref() else {
return None;
};
if helper_call.args.len() != 1 {
return None;
}
let helper_callee = helper_call.callee.as_expr()?;
if !is_async_to_gen_callee(helper_callee, async_to_gen_callees) {
return None;
}
Some(*helper_call.args[0].expr.clone())
}
fn extract_async_to_gen_body_with_params(
gen_fn_arg: Expr,
generator_helpers: &[BindingKey],
) -> Option<(Vec<Param>, Vec<Stmt>, Option<BindingKey>)> {
match gen_fn_arg {
Expr::Fn(fn_expr) => {
let params = fn_expr.function.params.clone();
if fn_expr.function.is_generator {
return Some((params, fn_expr.function.body?.stmts, None));
}
let mut body = fn_expr.function.body?;
let mark_key = if let Some(mark_key) = try_transform_regenerator_wrap(&mut body) {
mark_key
} else if try_transform_ts_generator_body(&mut body, generator_helpers) {
None
} else {
return None;
};
Some((params, body.stmts, mark_key))
}
Expr::Call(mark_call) => {
let callee_expr = mark_call.callee.as_expr()?;
let Expr::Member(member) = callee_expr.as_ref() else {
return None;
};
if !is_mark_prop(&member.prop) || mark_call.args.len() != 1 {
return None;
}
let Expr::Fn(fn_expr) = *mark_call.args.into_iter().next()?.expr else {
return None;
};
let params = fn_expr.function.params.clone();
let mut body = fn_expr.function.body?;
let mark_key = if let Some(mark_key) = try_transform_regenerator_wrap(&mut body) {
mark_key
} else if try_transform_ts_generator_body(&mut body, generator_helpers) {
None
} else {
return None;
};
Some((params, body.stmts, mark_key))
}
_ => None,
}
}
fn binding_used_outside_pair(
items: &[ModuleItem],
first: usize,
second: usize,
key: &BindingKey,
) -> bool {
items.iter().enumerate().any(|(index, item)| {
if index == first || index == second {
return false;
}
let mut finder = BindingUseFinder {
key: key.clone(),
found: false,
};
item.visit_with(&mut finder);
finder.found
})
}
struct BindingUseFinder {
key: BindingKey,
found: bool,
}
impl Visit for BindingUseFinder {
fn visit_var_declarator(&mut self, decl: &VarDeclarator) {
if let Some(init) = &decl.init {
init.visit_with(self);
}
}
fn visit_ident(&mut self, ident: &Ident) {
if ident.sym == self.key.0 && ident.ctxt == self.key.1 {
self.found = true;
}
}
}
struct FunctionTransformer<'a> {
unresolved_mark: Mark,
async_to_gen_callees: &'a AsyncToGenCallees<'a>,
generator_helpers: &'a [BindingKey],
esbuild_async_helpers: &'a [BindingKey],
esbuild_yield_star_helpers: &'a [BindingKey],
consumed_marks: &'a mut Vec<BindingKey>,
}
impl VisitMut for FunctionTransformer<'_> {
fn visit_mut_assign_expr(&mut self, assign: &mut AssignExpr) {
assign.visit_mut_children_with(self);
if let Some((expr, mark_key)) = try_transform_async_to_generator_expr(
*assign.right.clone(),
self.async_to_gen_callees,
self.generator_helpers,
) {
*assign.right = expr;
if let Some(mark_key) = mark_key {
self.consumed_marks.push(mark_key);
}
}
}
fn visit_mut_var_declarator(&mut self, decl: &mut VarDeclarator) {
decl.visit_mut_children_with(self);
let Some(init) = decl.init.take() else {
return;
};
if let Some((expr, mark_key)) = try_transform_async_to_generator_expr(
*init.clone(),
self.async_to_gen_callees,
self.generator_helpers,
) {
decl.init = Some(Box::new(expr));
if let Some(mark_key) = mark_key {
self.consumed_marks.push(mark_key);
}
} else if let Some(expr) = try_collapse_async_trampoline_iife(&init) {
decl.init = Some(Box::new(expr));
} else {
decl.init = Some(init);
}
}
fn visit_mut_function(&mut self, func: &mut Function) {
if let Some(body) = func.body.as_mut() {
if try_transform_esbuild_async_function(body, self.esbuild_async_helpers) {
func.is_async = true;
func.visit_mut_children_with(self);
return;
}
}
// Try _asyncToGenerator BEFORE recursing — the inner function hasn't
// been transformed yet, so we can still detect the full pattern.
if let Some(body) = func.body.as_mut() {
if try_transform_async_to_generator(
body,
self.async_to_gen_callees,
self.generator_helpers,
self.unresolved_mark,
) {
func.is_async = true;
// Still recurse into the (now-rewritten) body for nested cases
func.visit_mut_children_with(self);
return;
}
}
func.visit_mut_children_with(self);
let body = match func.body.as_mut() {
Some(b) => b,
None => return,
};
// Try regeneratorRuntime.wrap() transform
if let Some(mark_key) = try_transform_regenerator_wrap(body) {
func.is_generator = true;
if let Some(key) = mark_key {
self.consumed_marks.push(key);
}
}
}
fn visit_mut_arrow_expr(&mut self, arrow: &mut ArrowExpr) {
if try_transform_esbuild_async_arrow(arrow, self.esbuild_async_helpers) {
arrow.visit_mut_children_with(self);
return;
}
arrow.visit_mut_children_with(self);
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Call(call) = expr {
// _asyncToGenerator(fn)() IIFE
if call.args.is_empty() {
if let Callee::Expr(callee_expr) = &mut call.callee {
if is_paramless_async_to_gen_iife(callee_expr, self.async_to_gen_callees) {
if let Some((transformed, mark_key)) = try_transform_async_to_generator_expr(
callee_expr.as_ref().clone(),
self.async_to_gen_callees,
self.generator_helpers,
) {
let callee_span = callee_expr.span();
**callee_expr = Expr::Paren(ParenExpr {
span: callee_span,
expr: Box::new(transformed),
});
if let Some(mark_key) = mark_key {
self.consumed_marks.push(mark_key);
}
}
return;
}
}
}
// __async(this, null, fn*(){…}) standalone expression
if let Some(mut stmts) =
extract_esbuild_async_call_body(expr, self.esbuild_async_helpers)
{
let original_span = expr.span();
replace_yield_with_await(&mut stmts);
*expr = Expr::Call(CallExpr {
span: original_span,
ctxt: Default::default(),
callee: Callee::Expr(Box::new(Expr::Paren(ParenExpr {
span: DUMMY_SP,
expr: Box::new(Expr::Fn(FnExpr {
ident: None,
function: Box::new(Function {
params: vec![],
decorators: vec![],
span: DUMMY_SP,
ctxt: Default::default(),
body: Some(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts,
}),
is_generator: false,
is_async: true,
type_params: None,
return_type: None,
}),
})),
}))),
args: vec![],
type_args: None,
});
}
}
}
fn visit_mut_yield_expr(&mut self, yield_expr: &mut YieldExpr) {
yield_expr.visit_mut_children_with(self);
if !yield_expr.delegate {
return;
}
let Some(arg) = yield_expr.arg.take() else {
return;
};
if let Some(unwrapped) =
unwrap_esbuild_yield_star_arg(&arg, self.esbuild_yield_star_helpers)
{
yield_expr.arg = Some(unwrapped);
} else {
yield_expr.arg = Some(arg);
}
}
}
// ============================================================
// regeneratorRuntime.wrap() → function*
// ============================================================
/// Returns the consumed mark binding key (sym + ctxt) on success.
fn try_transform_regenerator_wrap(body: &mut BlockStmt) -> Option<Option<BindingKey>> {
let return_idx = body.stmts.iter().position(is_regenerator_wrap_return)?;
// P1-1: Pre-check for nested control flow before extracting.
if has_nested_control_flow_in_stmt(&body.stmts[return_idx]) {
return None;
}
// Extract the mark binding key (2nd arg to .wrap()) before consuming
let mark_name = extract_wrap_mark_key(&body.stmts[return_idx]);
let ret_stmt = body.stmts[return_idx].clone();
let (state_name, cases, try_regions) = extract_wrap_args(ret_stmt)?;
let new_stmts = decode_babel_state_machine(&state_name, cases, try_regions);
// Safety net: if a forward conditional jump could not be structured, an
// opcode goto (`return [3, N]`) leaks into the output. Rather than emit
// broken control flow, leave the function un-recovered.
if stmts_contain_state_opcode_return(&new_stmts, OpcodeReturnScan::IncludeNestedFunctions) {
return None;
}
body.stmts.remove(return_idx);
body.stmts.splice(return_idx..return_idx, new_stmts);
Some(mark_name)
}
/// Extract the mark binding key (sym + ctxt) from the 2nd argument of .wrap(fn, markIdent, ...)
fn extract_wrap_mark_key(stmt: &Stmt) -> Option<BindingKey> {
let Stmt::Return(ret) = stmt else { return None };
let arg = ret.arg.as_ref()?;
let Expr::Call(call) = arg.as_ref() else {
return None;
};
if call.args.len() < 2 {
return None;
}
let Expr::Ident(id) = call.args[1].expr.as_ref() else {
return None;
};
Some((id.sym.clone(), id.ctxt))
}
/// Check if the regenerator.wrap() state machine contains nested control flow
/// (if/else blocks with state transitions) that we can't safely linearize.
fn has_nested_control_flow_in_stmt(stmt: &Stmt) -> bool {
let Stmt::Return(ret) = stmt else {
return false;
};
let Some(arg) = &ret.arg else { return false };
let Expr::Call(call) = arg.as_ref() else {
return false;
};
if call.args.is_empty() {
return false;
}
let wrap_try_regions = extract_wrap_try_regions_from_call(call);
let fn_expr = &call.args[0].expr;
let cases = match fn_expr.as_ref() {
Expr::Fn(f) => {
let param_name = match f.function.params.first().map(|p| &p.pat) {
Some(Pat::Ident(bi)) => bi.id.sym.clone(),
_ => return false,
};
let Some(body) = &f.function.body else {
return false;
};
extract_switch_cases_ref(body).map(|c| (param_name, c))
}
Expr::Arrow(a) => {
let param_name = match a.params.first() {
Some(Pat::Ident(bi)) => bi.id.sym.clone(),
_ => return false,
};
match a.body.as_ref() {
swc_core::ecma::ast::BlockStmtOrExpr::BlockStmt(body) => {
extract_switch_cases_ref(body).map(|c| (param_name, c))
}
_ => None,
}
}
_ => None,
};
let Some((state_name, cases)) = cases else {
return false;
};
// Check each case's top-level statements for nested blocks that
// contain state machine operations (_ctx.next or break). A supported
// forward state-jump (`if (cond) { _ctx.next = N; break; }`) is decoded
// structurally, so it does not count as unsupported control flow.
for case in cases {
for stmt in &case.cons {
if has_state_ops_in_nested_block(&state_name, stmt)
&& !is_supported_nested_state_jump(&state_name, stmt)
{
return true;
}
}
}
// `_ctx.catch(...)` is only safe when Babel also supplied the try-region list
// as the 4th .wrap() argument.
if wrap_try_regions.is_empty() {
for case in cases {
if case_uses_catch(&state_name, case) {
return true;
}
}
}
false
}
fn is_supported_nested_state_jump(state_name: &Atom, stmt: &Stmt) -> bool {
let Stmt::If(if_stmt) = stmt else {
return false;
};
if if_stmt.alt.is_some() {
return false;
}
extract_next_break_target(state_name, &if_stmt.cons).is_some()
}
/// Check if a statement contains _ctx.next assignments or break statements
/// inside nested blocks (if/else, block statements, etc.) — not at the top level.
fn has_state_ops_in_nested_block(state_name: &Atom, stmt: &Stmt) -> bool {
match stmt {
Stmt::If(if_stmt) => {
has_state_ops_deep(state_name, &if_stmt.cons)
|| if_stmt
.alt
.as_ref()
.is_some_and(|alt| has_state_ops_deep(state_name, alt))
}
Stmt::Block(block) => block
.stmts
.iter()
.any(|s| has_state_ops_deep(state_name, s)),
_ => false,
}
}
fn has_state_ops_deep(state_name: &Atom, stmt: &Stmt) -> bool {
struct Finder {
state_name: Atom,
found: bool,
}
impl swc_core::ecma::visit::Visit for Finder {
fn visit_assign_expr(&mut self, assign: &swc_core::ecma::ast::AssignExpr) {
if let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) {
if is_ident_with_name(&left_member.obj, &self.state_name)
&& is_next_prop(&left_member.prop)
{
self.found = true;
return;
}
}
assign.visit_children_with(self);
}
fn visit_break_stmt(&mut self, _: &swc_core::ecma::ast::BreakStmt) {
self.found = true;
}
}
let mut f = Finder {
state_name: state_name.clone(),
found: false,
};
stmt.visit_with(&mut f);
f.found
}
/// Check if a switch case contains `_ctx.catch(...)` calls — signals try/catch.
fn case_uses_catch(state_name: &Atom, case: &SwitchCase) -> bool {
struct CatchFinder {
state_name: Atom,
found: bool,
}
impl swc_core::ecma::visit::Visit for CatchFinder {
fn visit_call_expr(&mut self, call: &swc_core::ecma::ast::CallExpr) {
if let Some(callee) = call.callee.as_expr() {
if let Expr::Member(member) = callee.as_ref() {
if is_ident_with_name(&member.obj, &self.state_name)
&& member_prop_name(&member.prop, "catch")
{
self.found = true;
return;
}
}
}
call.visit_children_with(self);
}
}
let mut f = CatchFinder {
state_name: state_name.clone(),
found: false,
};
for stmt in &case.cons {
stmt.visit_with(&mut f);
if f.found {
return true;
}
}
false
}
fn extract_switch_cases_ref(body: &BlockStmt) -> Option<&[SwitchCase]> {
for stmt in &body.stmts {
match stmt {
Stmt::While(while_stmt) => {
if let Some(cases) = switch_cases_from_loop_body_ref(while_stmt.body.as_ref()) {
return Some(cases);
}
}
Stmt::For(for_stmt) => {
if let Some(cases) = switch_cases_from_loop_body_ref(for_stmt.body.as_ref()) {
return Some(cases);
}
}
_ => {}
}
}
None
}
fn is_regenerator_wrap_return(stmt: &Stmt) -> bool {
let Stmt::Return(ret) = stmt else {
return false;
};
let Some(arg) = &ret.arg else { return false };
is_wrap_call(arg)
}
/// Check if expr is `<something>.wrap(stateMachineFn, ...)` or Babel 7.27+
/// `<something>.w(stateMachineFn, ...)`.
/// where stateMachineFn contains the distinctive `while(true) { switch(param.prev = param.next) }` pattern.
fn is_wrap_call(expr: &Expr) -> bool {
let Expr::Call(call) = expr else {
return false;
};
let Some(callee_expr) = call.callee.as_expr() else {
return false;
};
let Expr::Member(member) = callee_expr.as_ref() else {
return false;
};
if !is_wrap_prop(&member.prop) {
return false;
}
if call.args.is_empty() {
return false;
}
// Validate that the first argument is a state machine function
is_state_machine_fn(&call.args[0].expr)
}
/// Check if an expression is a state machine function:
/// `function(param) { while(true) { switch(param.prev = param.next) { ... } } }`
/// or arrow: `(param) => { while(true) { switch(...) { ... } } }`
fn is_state_machine_fn(expr: &Expr) -> bool {
match expr {
Expr::Fn(fn_expr) => {
if fn_expr.function.params.len() != 1 {
return false;
}
let param_name = match &fn_expr.function.params[0].pat {
Pat::Ident(bi) => &bi.id.sym,
_ => return false,
};
let Some(body) = &fn_expr.function.body else {
return false;
};
has_state_machine_structure(body, param_name)
}
Expr::Arrow(arrow) => {
if arrow.params.len() != 1 {
return false;
}
let param_name = match &arrow.params[0] {
Pat::Ident(bi) => &bi.id.sym,
_ => return false,
};
match arrow.body.as_ref() {
swc_core::ecma::ast::BlockStmtOrExpr::BlockStmt(body) => {
has_state_machine_structure(body, param_name)
}
_ => false,
}
}
_ => false,
}
}
/// Check for `while(true) { switch(param.prev = param.next) { ... case "end": ... } }`
/// or `for(;;) { switch(...) { ... } }`
fn has_state_machine_structure(body: &BlockStmt, param_name: &Atom) -> bool {
// Look for a while(true) or for(;;) loop containing the switch
for stmt in &body.stmts {
match stmt {
Stmt::While(while_stmt) => {
if !is_true_expr(&while_stmt.test) {
continue;
}
if loop_body_has_state_switch(while_stmt.body.as_ref(), param_name) {
return true;
}
}
Stmt::For(for_stmt) => {
// for(;;) — init, test, update all None
if for_stmt.init.is_some() || for_stmt.test.is_some() || for_stmt.update.is_some() {
continue;
}
if loop_body_has_state_switch(for_stmt.body.as_ref(), param_name) {
return true;
}
}
_ => {}
}
}
false
}
fn is_true_expr(expr: &Expr) -> bool {
match expr {
Expr::Lit(Lit::Bool(b)) => b.value,
Expr::Lit(Lit::Num(n)) => n.value != 0.0,
_ => false,
}
}
/// Check if a block contains `switch(param.prev = param.next) { ... }` or
/// Babel 7.27+ `switch(param.n) { ... }`.
fn has_state_switch(block: &BlockStmt, param_name: &Atom) -> bool {
for stmt in &block.stmts {
if let Stmt::Switch(sw) = stmt {
if is_state_switch_discriminant(&sw.discriminant, param_name) {
return true;
}
}
}
false
}
fn loop_body_has_state_switch(stmt: &Stmt, param_name: &Atom) -> bool {
match stmt {
Stmt::Switch(sw) => is_state_switch_discriminant(&sw.discriminant, param_name),
Stmt::Block(block) => has_state_switch(block, param_name),
_ => false,
}
}
fn switch_cases_from_loop_body_ref(stmt: &Stmt) -> Option<&[SwitchCase]> {
match stmt {
Stmt::Switch(sw) => Some(&sw.cases),
Stmt::Block(block) => {
for inner in &block.stmts {
if let Stmt::Switch(sw) = inner {
return Some(&sw.cases);
}
}
None
}
_ => None,
}
}
fn is_state_switch_discriminant(expr: &Expr, param_name: &Atom) -> bool {
if let Expr::Member(member) = expr {
return is_ident_with_name(&member.obj, param_name) && is_next_prop(&member.prop);
}
let Expr::Assign(assign) = expr else {
return false;
};
if assign.op != AssignOp::Assign {
return false;
}
// Left: param.prev or Babel 7.27+ param.p
let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) else {
return false;
};
if !is_ident_with_name(&left_member.obj, param_name) || !is_prev_prop(&left_member.prop) {
return false;
}
let Expr::Member(right_member) = assign.right.as_ref() else {
return false;
};
is_ident_with_name(&right_member.obj, param_name) && is_next_prop(&right_member.prop)
}
fn extract_wrap_args(stmt: Stmt) -> Option<(Atom, Vec<SwitchCase>, Vec<[Option<usize>; 4]>)> {
let Stmt::Return(ret) = stmt else { return None };
let arg = *ret.arg?;
let Expr::Call(call) = arg else { return None };
let callee_expr = call.callee.as_expr()?;
let Expr::Member(member) = callee_expr.as_ref() else {
return None;
};
if !is_wrap_prop(&member.prop) {
return None;
}
if call.args.is_empty() {
return None;
}
let try_regions = extract_wrap_try_regions_from_call(&call);
let fn_arg = *call.args.into_iter().next()?.expr;
let (state_name, cases) = extract_state_machine_parts(fn_arg)?;
Some((state_name, cases, try_regions))
}
fn extract_wrap_try_regions_from_call(
call: &swc_core::ecma::ast::CallExpr,
) -> Vec<[Option<usize>; 4]> {
let Some(arg4) = call.args.get(3) else {
return Vec::new();
};
let Expr::Array(arr) = arg4.expr.as_ref() else {
return Vec::new();
};
arr.elems
.iter()
.filter_map(|elem| {
let elem = elem.as_ref()?;
let Expr::Array(region) = elem.expr.as_ref() else {
return None;
};
parse_try_region_array(region)
})
.collect()
}
fn parse_try_region_array(arr: &ArrayLit) -> Option<[Option<usize>; 4]> {
if arr.elems.len() < 2 {
return None;
}
let mut region = [None; 4];
for (i, elem) in arr.elems.iter().enumerate().take(4) {
region[i] = elem.as_ref().and_then(|e| {
if let Expr::Lit(Lit::Num(n)) = e.expr.as_ref() {
Some(n.value as usize)
} else {
None
}
});
}
Some(region)
}
fn extract_state_machine_parts(expr: Expr) -> Option<(Atom, Vec<SwitchCase>)> {
match expr {
Expr::Fn(fn_expr) => {
let param_name = match &fn_expr.function.params.first()?.pat {
Pat::Ident(bi) => bi.id.sym.clone(),
_ => return None,
};
let body = fn_expr.function.body?;
let cases = extract_switch_cases_from_body(body)?;
Some((param_name, cases))
}
Expr::Arrow(arrow) => {
let param_name = match &arrow.params.first()? {
Pat::Ident(bi) => bi.id.sym.clone(),
_ => return None,
};
let body = match *arrow.body {
swc_core::ecma::ast::BlockStmtOrExpr::BlockStmt(b) => b,
_ => return None,
};
let cases = extract_switch_cases_from_body(body)?;
Some((param_name, cases))
}
_ => None,
}
}
fn extract_switch_cases_from_body(body: BlockStmt) -> Option<Vec<SwitchCase>> {
// Find the while(true) or for(;;) loop, then the switch inside
for stmt in body.stmts {
match stmt {
Stmt::While(while_stmt) => {
if let Some(cases) = switch_cases_from_loop_body(*while_stmt.body) {
return Some(cases);
}
}
Stmt::For(for_stmt) => {
if let Some(cases) = switch_cases_from_loop_body(*for_stmt.body) {
return Some(cases);
}
}
_ => {}
}
}
None
}
fn switch_cases_from_loop_body(stmt: Stmt) -> Option<Vec<SwitchCase>> {
match stmt {
Stmt::Switch(sw) => Some(sw.cases),
Stmt::Block(block) => {
for inner in block.stmts {
if let Stmt::Switch(sw) = inner {
return Some(sw.cases);
}
}
None
}
_ => None,
}
}
// ============================================================
// Babel state machine decoder
// ============================================================
fn decode_babel_state_machine(
state_name: &Atom,
cases: Vec<SwitchCase>,
mut trys: Vec<[Option<usize>; 4]>,
) -> Vec<Stmt> {
infer_try_region_nexts(&mut trys, &cases);
// Collect (label_idx, stmt) pairs
let mut flat: Vec<(usize, Stmt)> = Vec::new();
let mut skip_delegate_result_assignments: HashSet<(usize, usize)> = HashSet::new();
for case in &cases {
let idx = match case_label_index(case) {
Some(n) => n,
None => continue, // skip "end" case
};
let next_case_label = next_numeric_case_label(&cases, idx);
let mut catch_aliases = Vec::new();
let is_catch = is_catch_label(idx, &trys);
let stmts = &case.cons;
let mut i = 0;
while i < stmts.len() {
let stmt = &stmts[i];
if skip_delegate_result_assignments.contains(&(idx, i)) {
i += 1;
continue;
}
// Detect _ctx.next = N; break; pairs. When N < idx (a back-edge),
// preserve the goto as `return [3, N]` so `recover_index_loops`
// can reconstruct for-loops. Forward/fallthrough gotos are dropped.
if is_next_assign(state_name, stmt) {
if let Some(target) = extract_state_next_assign_target(state_name, stmt) {
if i + 1 < stmts.len() && matches!(stmts[i + 1], Stmt::Break(_)) {
if target > 0
&& (target < idx || (target > idx && Some(target) != next_case_label))
&& !is_try_region_exit(idx, target, &trys)
{
flat.push((idx, jump_return_stmt(target)));
}
i += 2;
continue;
}
}
i += 1;
continue;
}
// Skip Babel's `_ctx.prev = N` / `_ctx.p = N` bookkeeping.
if is_prev_assign(state_name, stmt) {
i += 1;
continue;
}
// Skip _ctx.label = N (tslib-style, shouldn't appear but be safe)
if is_label_assign(state_name, stmt) {
i += 1;
continue;
}
// Handle _ctx.trys.push([...]) for try/catch regions
if let Some(region) = extract_trys_push(state_name, stmt) {
trys.push(region);
i += 1;
continue;
}
if is_catch {
if let Some(alias) = extract_catch_value_alias(state_name, stmt) {
catch_aliases.push(alias);
i += 1;
continue;
}
}
let mut stmt = stmt.clone();
if is_catch {
let mut replacer = CatchValueReplacer {
state_name: state_name.clone(),
aliases: catch_aliases.clone(),
replacement: Box::new(Expr::Ident(Ident::new_no_ctxt(
"error".into(),
DUMMY_SP,
))),
};
stmt.visit_mut_with(&mut replacer);
}
if let Some((decoded, consumed)) = decode_nested_state_jump(state_name, &stmts[i..]) {
flat.push((idx, decoded));
i += consumed;
continue;
}
// Handle return statements (yields, abrupt returns, stop)
if let Stmt::Return(ret) = &stmt {
if let Some(decoded) = decode_return(state_name, ret) {
match decoded {
DecodedReturn::Return(expr) => {
flat.push((
idx,
Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(expr),
}),
));
}
DecodedReturn::ReturnVoid => {
flat.push((
idx,
Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: None,
}),
));
}
DecodedReturn::Throw(expr) => {
flat.push((
idx,
Stmt::Throw(swc_core::ecma::ast::ThrowStmt {
span: DUMMY_SP,
arg: expr,
}),
));
}
DecodedReturn::Stop => {} // end of generator, drop
DecodedReturn::CommaYield(expr) => {
// return _ctx.next = N, value → yield value
flat.push((
idx,
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Yield(YieldExpr {
span: DUMMY_SP,
delegate: false,
arg: Some(expr),
})),
}),
));
}
DecodedReturn::DelegateYield {
expr,
result_name,
next_loc,
} => {
if let (Some(result_name), Some(next_loc)) =
(result_name.as_ref(), next_loc)
{
if let Some((assign_index, assign_stmt)) =
extract_delegate_result_assignment(
state_name,
&cases,
next_loc,
result_name,
expr.clone(),
)
{
skip_delegate_result_assignments
.insert((next_loc, assign_index));
flat.push((idx, assign_stmt));
} else {
flat.push((
idx,
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: delegate_yield_expr(expr),
}),
));
}
} else {
flat.push((
idx,
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: delegate_yield_expr(expr),
}),
));
}
}
}
i += 1;
continue;
}
// Plain return with non-pattern expression: treat as yield
if let Some(arg) = &ret.arg {
if !is_stop_call(state_name, arg) {
flat.push((
idx,
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Yield(YieldExpr {
span: DUMMY_SP,
delegate: false,
arg: Some(arg.clone()),
})),
}),
));
i += 1;
continue;
}
}
i += 1;
continue;
}
// Handle break — if the last _ctx.next pointed back to case 0 this is a loop,
// otherwise it's just a goto (skip it)
if matches!(stmt, Stmt::Break(_)) {
i += 1;
continue;
}
// Regular statement — emit as-is
flat.push((idx, stmt));
i += 1;
}
}
// Phase 2: merge _ctx.sent with previous yield
let mut output: Vec<(usize, Stmt)> = Vec::new();
for (idx, stmt) in flat {
if is_standalone_sent(state_name, &stmt) {
continue;
}
if stmt_uses_sent(state_name, &stmt) {
if is_catch_label(idx, &trys) {
let mut replacer = SentReplacer {
state_name: state_name.clone(),
replacement: Box::new(Expr::Ident(Ident::new_no_ctxt(
"error".into(),
DUMMY_SP,
))),
};
let mut s = stmt;
s.visit_mut_with(&mut replacer);
output.push((idx, s));
continue;
}
let merged = if let Some((_, prev)) = output.last() {
extract_yield_from_stmt(prev).map(|arg| {
let yield_expr = Box::new(Expr::Yield(YieldExpr {
span: DUMMY_SP,
delegate: false,
arg: Some(arg),
}));
let mut replacer = SentReplacer {
state_name: state_name.clone(),
replacement: yield_expr,
};
let mut s = stmt.clone();
s.visit_mut_with(&mut replacer);
s
})
} else {
None
};
if let Some(merged_stmt) = merged {
output.pop();
output.push((idx, merged_stmt));
} else {
let mut replacer = SentReplacer {
state_name: state_name.clone(),
replacement: Box::new(Expr::Ident(Ident::new_no_ctxt(
"undefined".into(),
DUMMY_SP,
))),
};
let mut s = stmt;
s.visit_mut_with(&mut replacer);
output.push((idx, s));
}
} else {
output.push((idx, stmt));
}
}
// Phase 3: Detect infinite loops (case 0 → ... → goto 0 pattern)
let has_back_edge_to_zero = detect_back_edge_to_zero(state_name, &cases);
let mut result = StateMachineProgram::from_labeled_stmts(output, trys)
.recover_conditional_assignments()
.recover_conditional_branches(OpcodeReturnScan::IncludeNestedFunctions)
// MidMachine joins are unsound here: a regenerator yield resumes at the
// `_ctx.next` label set before it, not the lexically next case, so
// folding up to a join can keep blocks the original machine skips
// (see bail_on_nested_control_flow).
.resolve_labeled_forward_jumps(
OpcodeReturnScan::IncludeNestedFunctions,
ForwardJumpJoin::EndOfMachine,
)
.into_reconstructed_stmts_with_index_loops(IndexLoopContinueMode::SingleBodyJumpTarget);
fold_state_temp_member_calls(state_name, &mut result);
// Wrap in while(true) if we detected a back-edge to case 0
if has_back_edge_to_zero && !result.is_empty() {
result = vec![Stmt::While(WhileStmt {
span: DUMMY_SP,
test: Box::new(Expr::Lit(Lit::Bool(swc_core::ecma::ast::Bool {
span: DUMMY_SP,
value: true,
}))),
body: Box::new(Stmt::Block(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts: result,
})),
})];
}
result
}
fn detect_back_edge_to_zero(state_name: &Atom, cases: &[SwitchCase]) -> bool {
for case in cases {
let idx = match case_label_index(case) {
Some(n) => n,
None => continue,
};
if idx == 0 {
continue;
}
for stmt in &case.cons {
if is_next_assign_to(state_name, stmt, 0) {
return true;
}
// Check comma operator: return _ctx.next = 0, ...
if let Stmt::Return(ret) = stmt {
if let Some(arg) = &ret.arg {
if is_comma_next_assign_to(state_name, arg, 0) {
return true;
}
}
}
}
}
false
}
fn decode_nested_state_jump(state_name: &Atom, stmts: &[Stmt]) -> Option<(Stmt, usize)> {
let Stmt::If(if_stmt) = stmts.first()? else {
return None;
};
if if_stmt.alt.is_some() {
return None;
}
let goto_target = extract_next_break_target(state_name, &if_stmt.cons)?;
if let Some(continue_target) = stmts
.get(1)
.and_then(|stmt| extract_continue_target(state_name, stmt))
{
if continue_target != goto_target {
return Some((
jump_if_stmt(invert_condition(&if_stmt.test), continue_target),
2,
));
}
}
Some((jump_if_stmt(if_stmt.test.clone(), goto_target), 1))
}
fn extract_next_break_target(state_name: &Atom, stmt: &Stmt) -> Option<usize> {
let Stmt::Block(block) = stmt else {
return None;
};
if block.stmts.len() != 2 || !matches!(block.stmts[1], Stmt::Break(_)) {
return None;
}
extract_state_next_assign_target(state_name, &block.stmts[0])
}
fn extract_state_next_assign_target(state_name: &Atom, stmt: &Stmt) -> Option<usize> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let left_member = assign.left.as_simple().and_then(|s| s.as_member())?;
if !is_ident_with_name(&left_member.obj, state_name) || !is_next_prop(&left_member.prop) {
return None;
}
number_lit_usize(&assign.right)
}
fn extract_continue_target(state_name: &Atom, stmt: &Stmt) -> Option<usize> {
extract_abrupt_continue_target(state_name, stmt)
.or_else(|| extract_short_continue_target(state_name, stmt))
}
fn extract_abrupt_continue_target(state_name: &Atom, stmt: &Stmt) -> Option<usize> {
let Stmt::Return(ret) = stmt else {
return None;
};
let Expr::Call(call) = ret.arg.as_deref()? else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !is_ident_with_name(&member.obj, state_name) || !member_prop_name(&member.prop, "abrupt") {
return None;
}
let Expr::Lit(Lit::Str(kind)) = call.args.first()?.expr.as_ref() else {
return None;
};
if kind.value.as_str() != Some("continue") {
return None;
}
number_lit_usize(&call.args.get(1)?.expr)
}
fn extract_short_continue_target(state_name: &Atom, stmt: &Stmt) -> Option<usize> {
let Stmt::Return(ret) = stmt else {
return None;
};
let Expr::Call(call) = ret.arg.as_deref()? else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !is_ident_with_name(&member.obj, state_name) || !member_prop_name(&member.prop, "a") {
return None;
}
let Expr::Lit(Lit::Num(kind)) = call.args.first()?.expr.as_ref() else {
return None;
};
if kind.value as u8 != 3 {
return None;
}
number_lit_usize(&call.args.get(1)?.expr)
}
fn jump_if_stmt(test: Box<Expr>, target: usize) -> Stmt {
Stmt::If(swc_core::ecma::ast::IfStmt {
span: DUMMY_SP,
test,
cons: Box::new(jump_return_stmt(target)),
alt: None,
})
}
fn jump_return_stmt(target: usize) -> Stmt {
Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(Box::new(Expr::Array(ArrayLit {
span: DUMMY_SP,
elems: vec![
Some(number_array_elem(3.0)),
Some(number_array_elem(target as f64)),
],
}))),
})
}
fn number_array_elem(value: f64) -> ExprOrSpread {
ExprOrSpread {
spread: None,
expr: Box::new(Expr::Lit(Lit::Num(Number {
span: DUMMY_SP,
value,
raw: None,
}))),
}
}
fn infer_try_region_nexts(trys: &mut [[Option<usize>; 4]], cases: &[SwitchCase]) {
for region in trys.iter_mut() {
if region[3].is_some() {
continue;
}
let Some(start) = region[0] else {
continue;
};
let Some(region_body_end) = region[1].or(region[2]) else {
continue;
};
let next = cases
.iter()
.filter_map(|case| {
let idx = case_label_index(case)?;
if idx < start || idx >= region_body_end {
return None;
}
case.cons
.iter()
.filter_map(extract_next_assign_target)
.filter(|target| *target > region_body_end)
.min()
})
.min();
region[3] = next;
}
}
fn is_try_region_exit(label: usize, target: usize, trys: &[[Option<usize>; 4]]) -> bool {
trys.iter().any(|region| {
let Some(start) = region[0] else {
return false;
};
let Some(end) = region[3].or(region[2]).or(region[1]) else {
return false;
};
if label < start || label >= end {
return false;
}
region[3].is_some_and(|next| target == next)
|| region[2].is_some_and(|finally_start| target == finally_start)
})
}
fn is_next_assign_to(state_name: &Atom, stmt: &Stmt, target: usize) -> 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 {
return false;
}
let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) else {
return false;
};
if !is_ident_with_name(&left_member.obj, state_name) || !is_next_prop(&left_member.prop) {
return false;
}
if let Expr::Lit(Lit::Num(n)) = assign.right.as_ref() {
return n.value as usize == target;
}
false
}
fn is_comma_next_assign_to(state_name: &Atom, expr: &Expr, target: usize) -> bool {
let Expr::Seq(seq) = expr else {
return false;
};
for e in &seq.exprs {
if let Expr::Assign(assign) = e.as_ref() {
if assign.op != AssignOp::Assign {
continue;
}
let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) else {
continue;
};
if is_ident_with_name(&left_member.obj, state_name) && is_next_prop(&left_member.prop) {
if let Expr::Lit(Lit::Num(n)) = assign.right.as_ref() {
if n.value as usize == target {
return true;
}
}
}
}
}
false
}
enum DecodedReturn {
Return(Box<Expr>),
ReturnVoid,
Throw(Box<Expr>),
Stop,
CommaYield(Box<Expr>),
DelegateYield {
expr: Box<Expr>,
result_name: Option<Atom>,
next_loc: Option<usize>,
},
}
fn decode_return(state_name: &Atom, ret: &ReturnStmt) -> Option<DecodedReturn> {
let arg = ret.arg.as_ref()?;
// return _ctx.stop()
if is_stop_call(state_name, arg) || is_finish_call(state_name, arg) {
return Some(DecodedReturn::Stop);
}
if let Some(decoded) = decode_delegate_yield(state_name, arg) {
return Some(decoded);
}
// return _ctx.abrupt("return", value)
if let Some(decoded) = decode_abrupt(state_name, arg) {
return Some(decoded);
}
// Babel 7.27+: return _ctx.a(2, value)
if let Some(decoded) = decode_short_abrupt(state_name, arg) {
return Some(decoded);
}
// return (_ctx.next = N, value) — comma operator form
if let Expr::Seq(seq) = arg.as_ref() {
if seq.exprs.len() >= 2 {
// Check if first expression is _ctx.next = N
if is_next_assign_expr(state_name, &seq.exprs[0]) {
let value = seq.exprs.last().unwrap().clone();
return Some(DecodedReturn::CommaYield(value));
}
}
}
None
}
fn decode_delegate_yield(state_name: &Atom, expr: &Expr) -> Option<DecodedReturn> {
let Expr::Call(call) = expr else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !is_ident_with_name(&member.obj, state_name)
|| !(member_prop_name(&member.prop, "delegateYield") || member_prop_name(&member.prop, "d"))
{
return None;
}
let arg = call.args.first()?.expr.clone();
let result_name = call.args.get(1).and_then(|arg| {
if let Expr::Lit(Lit::Str(str_lit)) = arg.expr.as_ref() {
str_lit.value.as_str().map(Atom::from)
} else {
None
}
});
let next_arg = if result_name.is_some() {
call.args.get(2)
} else {
call.args.get(1)
};
let next_loc = next_arg.and_then(|arg| number_lit_usize(&arg.expr));
Some(DecodedReturn::DelegateYield {
// Name-based unwrap during decode; the post-pass handles minified
// aliases via detected helper bindings.
expr: unwrap_regenerator_values(arg, &[]),
result_name,
next_loc,
})
}
fn extract_delegate_result_assignment(
state_name: &Atom,
cases: &[SwitchCase],
next_loc: usize,
result_name: &Atom,
yielded: Box<Expr>,
) -> Option<(usize, Stmt)> {
let case = cases
.iter()
.find(|case| case_label_index(case) == Some(next_loc))?;
for (stmt_index, stmt) in case.cons.iter().enumerate() {
if is_next_assign(state_name, stmt)
|| is_prev_assign(state_name, stmt)
|| is_label_assign(state_name, stmt)
{
continue;
}
return rewrite_delegate_result_assignment(state_name, result_name, yielded, stmt)
.map(|stmt| (stmt_index, stmt));
}
None
}
fn rewrite_delegate_result_assignment(
state_name: &Atom,
result_name: &Atom,
yielded: Box<Expr>,
stmt: &Stmt,
) -> Option<Stmt> {
match stmt {
Stmt::Expr(ExprStmt { expr, .. }) => {
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign
|| !is_state_result_expr(state_name, &assign.right, result_name)
{
return None;
}
let mut assign = assign.clone();
assign.right = delegate_yield_expr(yielded);
Some(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Assign(assign)),
}))
}
Stmt::Decl(Decl::Var(var_decl)) => {
let mut changed = false;
let mut var_decl = var_decl.clone();
for decl in &mut var_decl.decls {
if decl
.init
.as_deref()
.is_some_and(|init| is_state_result_expr(state_name, init, result_name))
{
decl.init = Some(delegate_yield_expr(yielded.clone()));
changed = true;
}
}
changed.then_some(Stmt::Decl(Decl::Var(var_decl)))
}
_ => None,
}
}
fn delegate_yield_expr(expr: Box<Expr>) -> Box<Expr> {
Box::new(Expr::Yield(YieldExpr {
span: DUMMY_SP,
delegate: true,
arg: Some(expr),
}))
}
fn is_state_result_expr(state_name: &Atom, expr: &Expr, result_name: &Atom) -> bool {
let Expr::Member(member) = strip_parens(expr) else {
return false;
};
is_ident_with_name(&member.obj, state_name)
&& member_prop_atom(&member.prop).as_ref() == Some(result_name)
}
fn unwrap_regenerator_values(expr: Box<Expr>, helpers: &[BindingKey]) -> Box<Expr> {
let Expr::Call(call) = expr.as_ref() else {
return expr;
};
let Some(callee) = call.callee.as_expr() else {
return expr;
};
let Expr::Ident(id) = callee.as_ref() else {
return expr;
};
// Match the canonical `_regeneratorValues` name, or a detected helper
// binding (robust to minified/top-level-mangled aliases).
let is_values_helper = id.sym.as_ref().contains("regeneratorValues")
|| helpers
.iter()
.any(|(sym, ctxt)| id.sym == *sym && id.ctxt == *ctxt);
if is_values_helper {
return call
.args
.first()
.map(|arg| arg.expr.clone())
.unwrap_or(expr);
}
expr
}
fn is_stop_call(state_name: &Atom, expr: &Expr) -> bool {
let Expr::Call(call) = expr else {
return false;
};
let Some(callee) = call.callee.as_expr() else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
is_ident_with_name(&member.obj, state_name) && member_prop_name(&member.prop, "stop")
}
fn is_finish_call(state_name: &Atom, expr: &Expr) -> bool {
let Expr::Call(call) = expr else {
return false;
};
let Some(callee) = call.callee.as_expr() else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
is_ident_with_name(&member.obj, state_name)
&& (member_prop_name(&member.prop, "finish") || member_prop_name(&member.prop, "f"))
}
fn decode_abrupt(state_name: &Atom, expr: &Expr) -> Option<DecodedReturn> {
let Expr::Call(call) = expr else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !is_ident_with_name(&member.obj, state_name) || !member_prop_name(&member.prop, "abrupt") {
return None;
}
if call.args.is_empty() {
return None;
}
let Expr::Lit(Lit::Str(kind)) = call.args[0].expr.as_ref() else {
return None;
};
let kind_str = kind.value.as_str().unwrap_or("");
match kind_str {
"return" => {
if call.args.len() >= 2 {
Some(DecodedReturn::Return(call.args[1].expr.clone()))
} else {
Some(DecodedReturn::ReturnVoid)
}
}
"throw" => {
if call.args.len() >= 2 {
Some(DecodedReturn::Throw(call.args[1].expr.clone()))
} else {
None
}
}
_ => None,
}
}
fn decode_short_abrupt(state_name: &Atom, expr: &Expr) -> Option<DecodedReturn> {
let Expr::Call(call) = expr else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !is_ident_with_name(&member.obj, state_name) || !member_prop_name(&member.prop, "a") {
return None;
}
let Expr::Lit(Lit::Num(kind)) = call.args.first()?.expr.as_ref() else {
return None;
};
match kind.value as u8 {
1 => call
.args
.get(1)
.map(|arg| DecodedReturn::Throw(arg.expr.clone())),
2 => call
.args
.get(1)
.map(|arg| DecodedReturn::Return(arg.expr.clone()))
.or(Some(DecodedReturn::Stop)),
_ => None,
}
}
fn is_next_assign(state_name: &Atom, stmt: &Stmt) -> bool {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return false;
};
is_next_assign_expr(state_name, expr)
}
fn extract_next_assign_target(stmt: &Stmt) -> Option<usize> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let left_member = assign.left.as_simple().and_then(|s| s.as_member())?;
if !is_next_prop(&left_member.prop) {
return None;
}
let Expr::Lit(Lit::Num(n)) = assign.right.as_ref() else {
return None;
};
Some(n.value as usize)
}
fn is_next_assign_expr(state_name: &Atom, expr: &Expr) -> bool {
let Expr::Assign(assign) = expr else {
return false;
};
if assign.op != AssignOp::Assign {
return false;
}
let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) else {
return false;
};
is_ident_with_name(&left_member.obj, state_name) && is_next_prop(&left_member.prop)
}
fn is_next_prop(prop: &MemberProp) -> bool {
member_prop_name(prop, "next") || member_prop_name(prop, "n")
}
fn is_wrap_prop(prop: &MemberProp) -> bool {
member_prop_name(prop, "wrap") || member_prop_name(prop, "w")
}
fn is_mark_prop(prop: &MemberProp) -> bool {
member_prop_name(prop, "mark") || member_prop_name(prop, "m")
}
fn is_label_assign(state_name: &Atom, stmt: &Stmt) -> 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 {
return false;
}
let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) else {
return false;
};
is_ident_with_name(&left_member.obj, state_name) && member_prop_name(&left_member.prop, "label")
}
fn is_prev_assign(state_name: &Atom, stmt: &Stmt) -> 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 {
return false;
}
let Some(left_member) = assign.left.as_simple().and_then(|s| s.as_member()) else {
return false;
};
is_ident_with_name(&left_member.obj, state_name) && is_prev_prop(&left_member.prop)
}
fn is_prev_prop(prop: &MemberProp) -> bool {
member_prop_name(prop, "prev") || member_prop_name(prop, "p")
}
fn case_label_index(case: &SwitchCase) -> Option<usize> {
let test = case.test.as_ref()?;
if let Expr::Lit(Lit::Num(n)) = test.as_ref() {
Some(n.value as usize)
} else {
None // "end" case
}
}
fn next_numeric_case_label(cases: &[SwitchCase], current: usize) -> Option<usize> {
cases
.iter()
.filter_map(case_label_index)
.filter(|label| *label > current)
.min()
}
fn extract_trys_push(state_name: &Atom, stmt: &Stmt) -> Option<[Option<usize>; 4]> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Call(call) = expr.as_ref() else {
return None;
};
let callee_expr = call.callee.as_expr()?;
let Expr::Member(callee_mem) = callee_expr.as_ref() else {
return None;
};
let Expr::Member(outer_mem) = callee_mem.obj.as_ref() else {
return None;
};
if !is_ident_with_name(&outer_mem.obj, state_name) {
return None;
}
if !member_prop_name(&outer_mem.prop, "trys") {
return None;
}
if !member_prop_name(&callee_mem.prop, "push") {
return None;
}
if call.args.len() != 1 {
return None;
}
let Expr::Array(arr) = call.args[0].expr.as_ref() else {
return None;
};
parse_try_region_array(arr)
}
fn is_standalone_sent(state_name: &Atom, stmt: &Stmt) -> bool {
if let Stmt::Expr(ExprStmt { expr, .. }) = stmt {
return is_sent_access(state_name, expr);
}
false
}
fn is_sent_access(state_name: &Atom, expr: &Expr) -> bool {
// _ctx.sent (property access, not method call like tslib)
if let Expr::Member(member) = expr {
return is_ident_with_name(&member.obj, state_name) && is_sent_prop(&member.prop);
}
// Also handle _ctx.sent() (some versions use method call)
if let Expr::Call(call) = expr {
if let Some(callee) = call.callee.as_expr() {
if let Expr::Member(member) = callee.as_ref() {
return is_ident_with_name(&member.obj, state_name) && is_sent_prop(&member.prop);
}
}
}
false
}
fn stmt_uses_sent(state_name: &Atom, stmt: &Stmt) -> bool {
struct Finder {
state_name: Atom,
found: bool,
}
impl swc_core::ecma::visit::Visit for Finder {
fn visit_function(&mut self, _func: &Function) {}
fn visit_arrow_expr(&mut self, _arrow: &ArrowExpr) {}
fn visit_member_expr(&mut self, member: &MemberExpr) {
if is_ident_with_name(&member.obj, &self.state_name) && is_sent_prop(&member.prop) {
self.found = true;
return;
}
member.visit_children_with(self);
}
}
let mut f = Finder {
state_name: state_name.clone(),
found: false,
};
stmt.visit_with(&mut f);
f.found
}
fn extract_yield_from_stmt(stmt: &Stmt) -> Option<Box<Expr>> {
if let Stmt::Expr(ExprStmt { expr, .. }) = stmt {
if let Expr::Yield(y) = expr.as_ref() {
return y.arg.clone();
}
}
None
}
fn is_catch_label(label_idx: usize, trys: &[[Option<usize>; 4]]) -> bool {
trys.iter().any(|region| region[1] == Some(label_idx))
}
struct SentReplacer {
state_name: Atom,
replacement: Box<Expr>,
}
#[derive(Clone)]
enum CatchValueAlias {
StateMember(Atom),
LocalIdent(BindingKey),
}
fn extract_catch_value_alias(state_name: &Atom, stmt: &Stmt) -> Option<CatchValueAlias> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
if is_state_catch_call(state_name, &assign.right) {
let left_member = assign.left.as_simple()?.as_member()?;
if !is_ident_with_name(&left_member.obj, state_name) {
return None;
}
return member_prop_atom(&left_member.prop).map(CatchValueAlias::StateMember);
}
if is_sent_access(state_name, &assign.right) {
let ident = assign.left.as_simple()?.as_ident()?;
return Some(CatchValueAlias::LocalIdent((ident.sym.clone(), ident.ctxt)));
}
None
}
fn is_state_catch_call(state_name: &Atom, expr: &Expr) -> bool {
let Expr::Call(call) = expr else {
return false;
};
let Some(callee) = call.callee.as_expr() else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
is_ident_with_name(&member.obj, state_name) && member_prop_name(&member.prop, "catch")
}
struct CatchValueReplacer {
state_name: Atom,
aliases: Vec<CatchValueAlias>,
replacement: Box<Expr>,
}
impl VisitMut for CatchValueReplacer {
fn visit_mut_function(&mut self, _func: &mut Function) {}
fn visit_mut_arrow_expr(&mut self, _arrow: &mut ArrowExpr) {}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if is_sent_access(&self.state_name, expr) {
*expr = *self.replacement.clone();
return;
}
if let Expr::Ident(id) = expr {
if self.aliases.iter().any(|alias| {
matches!(alias, CatchValueAlias::LocalIdent((sym, ctxt)) if id.sym == *sym && id.ctxt == *ctxt)
}) {
*expr = *self.replacement.clone();
return;
}
}
if let Expr::Member(member) = expr {
if is_ident_with_name(&member.obj, &self.state_name) {
if let Some(prop) = member_prop_atom(&member.prop) {
if self.aliases.iter().any(|alias| {
matches!(alias, CatchValueAlias::StateMember(alias_prop) if *alias_prop == prop)
}) {
*expr = *self.replacement.clone();
return;
}
}
}
}
expr.visit_mut_children_with(self);
}
}
impl VisitMut for SentReplacer {
fn visit_mut_function(&mut self, _func: &mut Function) {}
fn visit_mut_arrow_expr(&mut self, _arrow: &mut ArrowExpr) {}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
// Replace _ctx.sent property access
if let Expr::Member(member) = expr {
if is_ident_with_name(&member.obj, &self.state_name) && is_sent_prop(&member.prop) {
let original_span = expr.span();
let mut replacement = *self.replacement.clone();
propagate_span(&mut replacement, original_span);
*expr = replacement;
return;
}
}
// Replace _ctx.sent() method call
if let Expr::Call(call) = expr {
if let Some(callee) = call.callee.as_expr() {
if let Expr::Member(member) = callee.as_ref() {
if is_ident_with_name(&member.obj, &self.state_name)
&& is_sent_prop(&member.prop)
{
let original_span = expr.span();
let mut replacement = *self.replacement.clone();
propagate_span(&mut replacement, original_span);
*expr = replacement;
return;
}
}
}
}
expr.visit_mut_children_with(self);
}
}
fn is_sent_prop(prop: &MemberProp) -> bool {
member_prop_name(prop, "sent") || member_prop_name(prop, "v")
}
fn fold_state_temp_member_calls(state_name: &Atom, stmts: &mut Vec<Stmt>) {
let mut folded = Vec::new();
let mut index = 0usize;
while index < stmts.len() {
if let Some((stmt, consumed)) = try_fold_state_temp_member_call(state_name, &stmts[index..])
.or_else(|| try_fold_local_temp_member_call(&stmts[index..]))
{
folded.push(stmt);
index += consumed;
} else {
let mut stmt = stmts[index].clone();
fold_state_temp_member_calls_in_stmt(state_name, &mut stmt);
folded.push(stmt);
index += 1;
}
}
*stmts = folded;
}
fn fold_state_temp_member_calls_in_stmt(state_name: &Atom, stmt: &mut Stmt) {
match stmt {
Stmt::Block(block) => fold_state_temp_member_calls(state_name, &mut block.stmts),
Stmt::For(for_stmt) => {
if let Stmt::Block(block) = for_stmt.body.as_mut() {
fold_state_temp_member_calls(state_name, &mut block.stmts);
}
}
Stmt::Try(try_stmt) => {
fold_state_temp_member_calls(state_name, &mut try_stmt.block.stmts);
if let Some(handler) = &mut try_stmt.handler {
fold_state_temp_member_calls(state_name, &mut handler.body.stmts);
}
if let Some(finalizer) = &mut try_stmt.finalizer {
fold_state_temp_member_calls(state_name, &mut finalizer.stmts);
}
}
Stmt::If(if_stmt) => {
fold_state_temp_member_calls_in_stmt(state_name, &mut if_stmt.cons);
if let Some(alt) = &mut if_stmt.alt {
fold_state_temp_member_calls_in_stmt(state_name, alt);
}
}
_ => {}
}
}
fn try_fold_state_temp_member_call(state_name: &Atom, stmts: &[Stmt]) -> Option<(Stmt, usize)> {
let (receiver_key, receiver) = extract_state_member_assign(state_name, stmts.first()?)?;
let (arg_key, arg) = extract_state_member_assign(state_name, stmts.get(1)?)?;
let call = extract_bound_state_member_call(
state_name,
stmts.get(2)?,
&receiver_key,
receiver,
&arg_key,
arg,
)?;
Some((
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Call(call)),
}),
3,
))
}
fn try_fold_local_temp_member_call(stmts: &[Stmt]) -> Option<(Stmt, usize)> {
let (receiver_key, receiver) = extract_local_temp_assign(stmts.first()?)?;
let call = extract_bound_local_member_call(stmts.get(1)?, &receiver_key, receiver)?;
if local_temp_read_before_reassign(&stmts[2..], &receiver_key) {
return None;
}
Some((
Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(Expr::Call(call)),
}),
2,
))
}
fn local_temp_read_before_reassign(stmts: &[Stmt], key: &BindingKey) -> bool {
for stmt in stmts {
if let Some(rhs) = direct_local_temp_reassign_rhs(stmt, key) {
return expr_reads_local_temp(rhs, key);
}
if stmt_reads_local_temp(stmt, key) {
return true;
}
}
false
}
fn direct_local_temp_reassign_rhs<'a>(stmt: &'a Stmt, key: &BindingKey) -> Option<&'a Expr> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign || !assign_target_matches_local_temp(&assign.left, key) {
return None;
}
Some(&assign.right)
}
fn stmt_reads_local_temp(stmt: &Stmt, key: &BindingKey) -> bool {
let mut finder = LocalTempReadFinder { key, found: false };
stmt.visit_with(&mut finder);
finder.found
}
fn expr_reads_local_temp(expr: &Expr, key: &BindingKey) -> bool {
let mut finder = LocalTempReadFinder { key, found: false };
expr.visit_with(&mut finder);
finder.found
}
struct LocalTempReadFinder<'a> {
key: &'a BindingKey,
found: bool,
}
impl Visit for LocalTempReadFinder<'_> {
fn visit_var_declarator(&mut self, decl: &VarDeclarator) {
if let Some(init) = &decl.init {
init.visit_with(self);
}
}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if !assign_target_matches_local_temp(&assign.left, self.key) {
assign.left.visit_with(self);
}
assign.right.visit_with(self);
}
fn visit_ident(&mut self, ident: &Ident) {
if ident.sym == self.key.0 && ident.ctxt == self.key.1 {
self.found = true;
}
}
}
fn assign_target_matches_local_temp(target: &AssignTarget, key: &BindingKey) -> bool {
matches!(
target,
AssignTarget::Simple(SimpleAssignTarget::Ident(binding))
if binding.id.sym == key.0 && binding.id.ctxt == key.1
)
}
fn extract_local_temp_assign(stmt: &Stmt) -> Option<(BindingKey, Box<Expr>)> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let ident = assign.left.as_simple()?.as_ident()?;
if !is_likely_generated_alias(&ident.sym) {
return None;
}
Some(((ident.sym.clone(), ident.ctxt), assign.right.clone()))
}
fn extract_bound_local_member_call(
stmt: &Stmt,
receiver_key: &BindingKey,
receiver: Box<Expr>,
) -> Option<CallExpr> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Call(call) = expr.as_ref() else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(call_member) = callee.as_ref() else {
return None;
};
if !member_prop_name(&call_member.prop, "call") {
return None;
}
let Expr::Member(method_member) = call_member.obj.as_ref() else {
return None;
};
if local_temp_key(&method_member.obj).as_ref() != Some(receiver_key) {
return None;
}
if call.args.is_empty() || local_temp_key(&call.args[0].expr).as_ref() != Some(receiver_key) {
return None;
}
let mut next = call.clone();
next.callee = Callee::Expr(Box::new(Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: receiver,
prop: method_member.prop.clone(),
})));
next.args.remove(0);
Some(next)
}
fn local_temp_key(expr: &Expr) -> Option<BindingKey> {
let Expr::Ident(id) = strip_parens(expr) else {
return None;
};
Some((id.sym.clone(), id.ctxt))
}
fn extract_state_member_assign(state_name: &Atom, stmt: &Stmt) -> Option<(Atom, Box<Expr>)> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let left_member = assign.left.as_simple().and_then(|s| s.as_member())?;
if !is_ident_with_name(&left_member.obj, state_name) {
return None;
}
let key = member_prop_atom(&left_member.prop)?;
Some((key, assign.right.clone()))
}
fn extract_bound_state_member_call(
state_name: &Atom,
stmt: &Stmt,
receiver_key: &Atom,
receiver: Box<Expr>,
arg_key: &Atom,
arg: Box<Expr>,
) -> Option<CallExpr> {
let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
return None;
};
let Expr::Call(call) = expr.as_ref() else {
return None;
};
let callee = call.callee.as_expr()?;
let Expr::Member(call_member) = callee.as_ref() else {
return None;
};
if !member_prop_name(&call_member.prop, "call") {
return None;
}
let Expr::Member(method_member) = call_member.obj.as_ref() else {
return None;
};
if state_member_key(state_name, &method_member.obj).as_ref() != Some(receiver_key) {
return None;
}
if call.args.len() != 2
|| state_member_key(state_name, &call.args[0].expr).as_ref() != Some(receiver_key)
|| state_member_key(state_name, &call.args[1].expr).as_ref() != Some(arg_key)
{
return None;
}
let mut next = call.clone();
next.callee = Callee::Expr(Box::new(Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: receiver,
prop: method_member.prop.clone(),
})));
next.args = vec![ExprOrSpread {
spread: None,
expr: arg,
}];
Some(next)
}
fn state_member_key(state_name: &Atom, expr: &Expr) -> Option<Atom> {
let Expr::Member(member) = strip_parens(expr) else {
return None;
};
if !is_ident_with_name(&member.obj, state_name) {
return None;
}
member_prop_atom(&member.prop)
}
// ============================================================
// Babel async arrow trampoline cleanup
// ============================================================
fn try_collapse_async_trampoline_iife(expr: &Expr) -> Option<Expr> {
let Expr::Call(call) = expr else {
return None;
};
if !call.args.is_empty() {
return None;
}
let callee = call.callee.as_expr()?;
let body = match strip_parens(callee) {
Expr::Fn(fn_expr) => fn_expr.function.body.as_ref()?,
Expr::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => block,
BlockStmtOrExpr::Expr(_) => return None,
},
_ => return None,
};
match body.stmts.as_slice() {
[decl_stmt, return_stmt] => {
let (binding, async_fn) = async_fn_binding_from_decl_stmt(decl_stmt)?;
if !return_stmt_applies_binding(return_stmt, &binding) {
return None;
}
Some(anonymous_async_fn_expr(async_fn))
}
[private_decl, public_decl, return_stmt] => {
let (private_binding, async_fn) = async_fn_binding_from_decl_stmt(private_decl)?;
let public_binding = forwarding_fn_decl_binding(public_decl, &private_binding)?;
if !return_stmt_returns_binding(return_stmt, &public_binding) {
return None;
}
Some(anonymous_async_fn_expr(async_fn))
}
_ => None,
}
}
fn collapse_async_trampoline_iifes(module: &mut Module) {
module.visit_mut_with(&mut AsyncTrampolineIifeCollapser);
}
struct AsyncTrampolineIifeCollapser;
impl VisitMut for AsyncTrampolineIifeCollapser {
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Some(mut collapsed) = try_collapse_async_trampoline_iife(expr) {
let original_span = expr.span();
propagate_span(&mut collapsed, original_span);
*expr = collapsed;
}
}
}
fn collapse_async_trampoline_sequences(module: &mut Module) {
let binding_ref_counts = collect_binding_ref_counts(module);
let mut collapser = AsyncTrampolineSequenceCollapser { binding_ref_counts };
module.visit_mut_with(&mut collapser);
}
struct AsyncTrampolineSequenceCollapser {
binding_ref_counts: HashMap<BindingKey, usize>,
}
impl VisitMut for AsyncTrampolineSequenceCollapser {
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Some(mut collapsed) =
try_collapse_async_trampoline_sequence(expr, &self.binding_ref_counts)
{
let original_span = expr.span();
propagate_span(&mut collapsed, original_span);
*expr = collapsed;
}
}
}
fn try_collapse_async_trampoline_sequence(
expr: &Expr,
binding_ref_counts: &HashMap<BindingKey, usize>,
) -> Option<Expr> {
let Expr::Seq(seq) = expr else {
return None;
};
let [assignment, wrapper] = seq.exprs.as_slice() else {
return None;
};
let (binding, async_fn) = async_fn_assignment_from_expr(assignment)?;
if binding_ref_counts.get(&binding).copied() != Some(2) {
return None;
}
if !expr_applies_binding(wrapper, &binding) {
return None;
}
Some(anonymous_async_fn_expr(async_fn))
}
fn collapse_async_trampoline_assignments(module: &mut Module) {
let mut index = 0;
while index + 1 < module.body.len() {
let Some((binding, async_fn)) = async_fn_assignment_from_item(&module.body[index]) else {
index += 1;
continue;
};
if !var_item_init_applies_binding(&module.body[index + 1], &binding) {
index += 1;
continue;
}
if binding_used_outside_pair(&module.body, index, index + 1, &binding) {
index += 1;
continue;
}
if let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = &mut module.body[index + 1] {
for decl in &mut var.decls {
if let Some(init) = &decl.init {
if expr_applies_binding(init, &binding) {
decl.init = Some(Box::new(anonymous_async_fn_expr(async_fn.clone())));
}
}
}
}
module.body.remove(index);
}
}
fn async_fn_assignment_from_expr(expr: &Expr) -> Option<(BindingKey, FnExpr)> {
let Expr::Assign(assign) = expr else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(left)) = &assign.left else {
return None;
};
let async_fn = async_fn_from_expr(&assign.right)?;
Some(((left.id.sym.clone(), left.id.ctxt), async_fn.clone()))
}
fn async_fn_binding_from_decl_stmt(stmt: &Stmt) -> Option<(BindingKey, FnExpr)> {
let Stmt::Decl(Decl::Var(var)) = stmt 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 async_fn = async_fn_from_expr(decl.init.as_deref()?)?;
Some(((binding.id.sym.clone(), binding.id.ctxt), async_fn.clone()))
}
fn async_fn_assignment_from_item(item: &ModuleItem) -> Option<(BindingKey, FnExpr)> {
let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = item else {
return None;
};
let Expr::Assign(assign) = expr.as_ref() else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(left)) = &assign.left else {
return None;
};
let async_fn = async_fn_from_expr(&assign.right)?;
Some(((left.id.sym.clone(), left.id.ctxt), async_fn.clone()))
}
fn async_fn_from_expr(expr: &Expr) -> Option<&FnExpr> {
let Expr::Fn(fn_expr) = expr else {
return None;
};
if fn_expr.function.is_async && !fn_expr.function.is_generator {
Some(fn_expr)
} else {
None
}
}
fn return_stmt_applies_binding(stmt: &Stmt, binding: &BindingKey) -> bool {
let Stmt::Return(ret) = stmt else {
return false;
};
let Some(arg) = ret.arg.as_deref() else {
return false;
};
expr_applies_binding(arg, binding)
}
fn return_stmt_returns_binding(stmt: &Stmt, binding: &BindingKey) -> bool {
let Stmt::Return(ret) = stmt else {
return false;
};
let Some(Expr::Ident(id)) = ret.arg.as_deref() else {
return false;
};
id.sym == binding.0 && id.ctxt == binding.1
}
fn forwarding_fn_decl_binding(stmt: &Stmt, target: &BindingKey) -> Option<BindingKey> {
let Stmt::Decl(Decl::Fn(fn_decl)) = stmt else {
return None;
};
let body = fn_decl.function.body.as_ref()?;
let [return_stmt] = body.stmts.as_slice() else {
return None;
};
if !return_stmt_applies_binding(return_stmt, target) {
return None;
}
Some((fn_decl.ident.sym.clone(), fn_decl.ident.ctxt))
}
fn var_item_init_applies_binding(item: &ModuleItem, binding: &BindingKey) -> bool {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
return false;
};
var.decls.iter().any(|decl| {
decl.init
.as_deref()
.is_some_and(|init| expr_applies_binding(init, binding))
})
}
fn expr_applies_binding(expr: &Expr, binding: &BindingKey) -> bool {
if extract_apply_this_arguments_callee(expr)
.is_some_and(|id| id.sym == binding.0 && id.ctxt == binding.1)
{
return true;
}
let Expr::Fn(fn_expr) = expr else {
return false;
};
let Some(body) = &fn_expr.function.body else {
return false;
};
let [stmt] = body.stmts.as_slice() else {
return false;
};
return_stmt_applies_binding(stmt, binding)
}
fn anonymous_async_fn_expr(mut fn_expr: FnExpr) -> Expr {
fn_expr.ident = None;
Expr::Fn(fn_expr)
}
fn collect_binding_ref_counts(module: &Module) -> HashMap<BindingKey, usize> {
let mut counter = BindingRefCounter {
counts: HashMap::new(),
};
module.visit_with(&mut counter);
counter.counts
}
struct BindingRefCounter {
counts: HashMap<BindingKey, usize>,
}
impl Visit for BindingRefCounter {
fn visit_var_declarator(&mut self, decl: &VarDeclarator) {
if let Some(init) = &decl.init {
init.visit_with(self);
}
}
fn visit_fn_decl(&mut self, fn_decl: &FnDecl) {
fn_decl.function.visit_with(self);
}
fn visit_fn_expr(&mut self, fn_expr: &FnExpr) {
fn_expr.function.visit_with(self);
}
fn visit_ident(&mut self, ident: &Ident) {
*self
.counts
.entry((ident.sym.clone(), ident.ctxt))
.or_default() += 1;
}
}
// ============================================================
// esbuild __async → async function
// ============================================================
/// Strips a `_regeneratorValues(...)` wrapper from `yield*` delegations whose
/// callee is a detected values-helper binding (post-decode, mangle-safe).
struct RegeneratorValuesUnwrapper<'a> {
helpers: &'a [BindingKey],
}
impl VisitMut for RegeneratorValuesUnwrapper<'_> {
fn visit_mut_yield_expr(&mut self, yield_expr: &mut YieldExpr) {
yield_expr.visit_mut_children_with(self);
if !yield_expr.delegate {
return;
}
if let Some(arg) = yield_expr.arg.take() {
yield_expr.arg = Some(unwrap_regenerator_values(arg, self.helpers));
}
}
}
/// Collect top-level `_regeneratorValues` helper bindings by canonical name or
/// by body shape (single iterable param, `Symbol.iterator` / `@@iterator`
/// lookup, `TypeError` on non-iterable), which survives minification.
fn collect_regenerator_values_helpers(module: &Module) -> Vec<BindingKey> {
let mut helpers = Vec::new();
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) => {
let name = fn_decl.ident.sym.as_ref();
if (name.contains("regeneratorValues") || is_likely_generated_alias(name))
&& fn_is_regenerator_values_helper(&fn_decl.function)
{
helpers.push(binding_key(&fn_decl.ident));
}
}
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
let name = binding.id.sym.as_ref();
if !name.contains("regeneratorValues") && !is_likely_generated_alias(name) {
continue;
}
if decl
.init
.as_deref()
.is_some_and(is_regenerator_values_helper_expr)
{
helpers.push(binding_key(&binding.id));
}
}
}
_ => {}
}
}
helpers
}
fn is_regenerator_values_helper_expr(expr: &Expr) -> bool {
match expr {
Expr::Fn(fn_expr) => fn_is_regenerator_values_helper(&fn_expr.function),
Expr::Arrow(arrow) => {
if arrow.params.len() != 1 {
return false;
}
let mut finder = RegeneratorValuesHelperFinder::default();
arrow.body.visit_with(&mut finder);
finder.has_shape()
}
_ => false,
}
}
fn fn_is_regenerator_values_helper(function: &Function) -> bool {
if function.params.len() != 1 {
return false;
}
let Some(body) = &function.body else {
return false;
};
let mut finder = RegeneratorValuesHelperFinder::default();
body.visit_with(&mut finder);
finder.has_shape()
}
#[derive(Default)]
struct RegeneratorValuesHelperFinder {
found_symbol_iterator: bool,
found_at_iterator: bool,
found_type_error: bool,
}
impl RegeneratorValuesHelperFinder {
fn has_shape(&self) -> bool {
self.found_symbol_iterator && self.found_at_iterator && self.found_type_error
}
}
impl Visit for RegeneratorValuesHelperFinder {
fn visit_member_expr(&mut self, member: &MemberExpr) {
if let Expr::Ident(obj) = member.obj.as_ref() {
if obj.sym.as_ref() == "Symbol" && member_prop_name(&member.prop, "iterator") {
self.found_symbol_iterator = true;
}
}
member.visit_children_with(self);
}
fn visit_ident(&mut self, ident: &Ident) {
if ident.sym.as_ref() == "TypeError" {
self.found_type_error = true;
}
}
fn visit_lit(&mut self, lit: &Lit) {
if let Lit::Str(str_lit) = lit {
if str_lit.value.as_str() == Some("@@iterator") {
self.found_at_iterator = true;
}
}
}
}
fn collect_esbuild_yield_star_helpers(module: &Module) -> Vec<BindingKey> {
module
.body
.iter()
.flat_map(|item| {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
return Vec::new();
};
var.decls
.iter()
.filter_map(|decl| {
let Pat::Ident(binding) = &decl.name else {
return None;
};
let name = binding.id.sym.as_ref();
if name != "__yieldStar" && !is_likely_generated_alias(name) {
return None;
}
let init = decl.init.as_deref()?;
if is_esbuild_yield_star_helper_expr(init) {
Some((binding.id.sym.clone(), binding.id.ctxt))
} else {
None
}
})
.collect::<Vec<_>>()
})
.collect()
}
fn is_esbuild_yield_star_helper_expr(expr: &Expr) -> bool {
match expr {
Expr::Arrow(arrow) => {
let mut finder = EsbuildYieldStarHelperFinder::default();
arrow.body.visit_with(&mut finder);
finder.has_shape()
}
Expr::Fn(fn_expr) => {
let Some(body) = &fn_expr.function.body else {
return false;
};
let mut finder = EsbuildYieldStarHelperFinder::default();
body.visit_with(&mut finder);
finder.has_shape()
}
_ => false,
}
}
#[derive(Default)]
struct EsbuildYieldStarHelperFinder {
found_async_iterator: bool,
found_iterator: bool,
found_await_wrapper: bool,
}
impl EsbuildYieldStarHelperFinder {
fn has_shape(&self) -> bool {
self.found_async_iterator && self.found_iterator && self.found_await_wrapper
}
}
impl Visit for EsbuildYieldStarHelperFinder {
fn visit_lit(&mut self, lit: &Lit) {
if let Lit::Str(str_lit) = lit {
if str_lit.value.as_str() == Some("asyncIterator") {
self.found_async_iterator = true;
}
if str_lit.value.as_str() == Some("iterator") {
self.found_iterator = true;
}
}
}
fn visit_new_expr(&mut self, new_expr: &swc_core::ecma::ast::NewExpr) {
if new_expr
.args
.as_ref()
.is_some_and(|args| args.len() == 2 && is_number_lit(&args[1].expr, 1.0))
{
self.found_await_wrapper = true;
}
new_expr.visit_children_with(self);
}
}
fn unwrap_esbuild_yield_star_arg(
expr: &Expr,
esbuild_yield_star_helpers: &[BindingKey],
) -> Option<Box<Expr>> {
let Expr::Call(call) = strip_parens(expr) else {
return None;
};
if call.args.len() != 1 {
return None;
}
let callee = call.callee.as_expr()?;
let Expr::Ident(id) = callee.as_ref() else {
return None;
};
if !esbuild_yield_star_helpers
.iter()
.any(|(sym, ctxt)| id.sym == *sym && id.ctxt == *ctxt)
{
return None;
}
Some(call.args[0].expr.clone())
}
fn collect_esbuild_async_helpers(module: &Module, unresolved_mark: Mark) -> Vec<BindingKey> {
module
.body
.iter()
.flat_map(|item| {
let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
return Vec::new();
};
var.decls
.iter()
.filter_map(|decl| {
let Pat::Ident(binding) = &decl.name else {
return None;
};
let name = binding.id.sym.as_ref();
if name != "__async" && !is_likely_generated_alias(name) {
return None;
}
let init = decl.init.as_deref()?;
if is_esbuild_async_helper_expr(init, unresolved_mark) {
Some((binding.id.sym.clone(), binding.id.ctxt))
} else {
None
}
})
.collect::<Vec<_>>()
})
.collect()
}
fn is_esbuild_async_helper_expr(expr: &Expr, unresolved_mark: Mark) -> bool {
let body = match expr {
Expr::Arrow(arrow) => arrow.body.as_ref(),
Expr::Fn(fn_expr) => {
let Some(body) = &fn_expr.function.body else {
return false;
};
return esbuild_async_helper_body_has_shape(&body.stmts, unresolved_mark);
}
_ => return false,
};
match body {
BlockStmtOrExpr::BlockStmt(block) => {
esbuild_async_helper_body_has_shape(&block.stmts, unresolved_mark)
}
BlockStmtOrExpr::Expr(expr) => {
let mut finder = EsbuildAsyncHelperFinder::new(unresolved_mark);
expr.visit_with(&mut finder);
finder.found_promise && finder.found_generator_apply
}
}
}
fn esbuild_async_helper_body_has_shape(stmts: &[Stmt], unresolved_mark: Mark) -> bool {
let mut finder = EsbuildAsyncHelperFinder::new(unresolved_mark);
for stmt in stmts {
stmt.visit_with(&mut finder);
}
finder.found_promise && finder.found_generator_apply
}
struct EsbuildAsyncHelperFinder {
unresolved_mark: Mark,
found_promise: bool,
found_generator_apply: bool,
}
impl EsbuildAsyncHelperFinder {
fn new(unresolved_mark: Mark) -> Self {
Self {
unresolved_mark,
found_promise: false,
found_generator_apply: false,
}
}
}
impl Visit for EsbuildAsyncHelperFinder {
fn visit_expr(&mut self, expr: &Expr) {
if let Expr::New(new_expr) = expr {
if matches!(
new_expr.callee.as_ref(),
Expr::Ident(id)
if id.sym.as_ref() == "Promise" && id.ctxt.outer() == self.unresolved_mark
) {
self.found_promise = true;
}
}
if let Expr::Call(call) = expr {
if let Some(callee) = call.callee.as_expr() {
if let Expr::Member(member) = callee.as_ref() {
if member_prop_name(&member.prop, "apply") {
self.found_generator_apply = true;
}
}
}
}
expr.visit_children_with(self);
}
}
fn try_transform_esbuild_async_function(
body: &mut BlockStmt,
esbuild_async_helpers: &[BindingKey],
) -> bool {
if body.stmts.len() != 1 {
return false;
}
let Stmt::Return(ret) = &body.stmts[0] else {
return false;
};
let Some(arg) = ret.arg.as_deref() else {
return false;
};
let Some(mut stmts) = extract_esbuild_async_call_body(arg, esbuild_async_helpers) else {
return false;
};
replace_yield_with_await(&mut stmts);
body.stmts = stmts;
true
}
fn try_transform_esbuild_async_arrow(
arrow: &mut ArrowExpr,
esbuild_async_helpers: &[BindingKey],
) -> bool {
let Some(mut stmts) = (match arrow.body.as_ref() {
BlockStmtOrExpr::Expr(expr) => extract_esbuild_async_call_body(expr, esbuild_async_helpers),
BlockStmtOrExpr::BlockStmt(block) if block.stmts.len() == 1 => {
let Stmt::Return(ret) = &block.stmts[0] else {
return false;
};
let Some(arg) = ret.arg.as_deref() else {
return false;
};
extract_esbuild_async_call_body(arg, esbuild_async_helpers)
}
_ => None,
}) else {
return false;
};
replace_yield_with_await(&mut stmts);
arrow.is_async = true;
*arrow.body = BlockStmtOrExpr::BlockStmt(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts,
});
true
}
fn extract_esbuild_async_call_body(
expr: &Expr,
esbuild_async_helpers: &[BindingKey],
) -> Option<Vec<Stmt>> {
let Expr::Call(call) = expr else {
return None;
};
if call.args.len() != 3 {
return None;
}
let callee = call.callee.as_expr()?;
if !is_esbuild_async_callee(callee, esbuild_async_helpers) {
return None;
}
if !is_esbuild_async_this_arg(&call.args[0].expr)
|| !is_esbuild_async_arguments_arg(&call.args[1].expr)
{
return None;
}
let Expr::Fn(fn_expr) = call.args[2].expr.as_ref() else {
return None;
};
if !fn_expr.function.is_generator || !fn_expr.function.params.is_empty() {
return None;
}
Some(fn_expr.function.body.as_ref()?.stmts.clone())
}
fn is_esbuild_async_this_arg(expr: &Expr) -> bool {
matches!(strip_parens(expr), Expr::This(_) | Expr::Lit(Lit::Null(_)))
}
fn is_esbuild_async_arguments_arg(expr: &Expr) -> bool {
match strip_parens(expr) {
Expr::Ident(id) => id.sym.as_ref() == "arguments",
Expr::Lit(Lit::Null(_)) => true,
_ => false,
}
}
fn is_esbuild_async_callee(expr: &Expr, esbuild_async_helpers: &[BindingKey]) -> bool {
let Expr::Ident(id) = expr else {
return false;
};
esbuild_async_helpers
.iter()
.any(|(sym, ctxt)| id.sym == *sym && id.ctxt == *ctxt)
}
// ============================================================
// _asyncToGenerator → async function
// ============================================================
fn is_paramless_async_to_gen_iife(expr: &Expr, async_to_gen_callees: &AsyncToGenCallees) -> bool {
let Expr::Call(call) = expr else {
return false;
};
if call.args.len() != 1 {
return false;
}
let Some(callee) = call.callee.as_expr() else {
return false;
};
if !is_async_to_gen_callee(callee, async_to_gen_callees) {
return false;
}
match call.args[0].expr.as_ref() {
Expr::Fn(fn_expr) => fn_expr.function.params.is_empty(),
Expr::Call(mark_call) => {
let Some(callee_expr) = mark_call.callee.as_expr() else {
return false;
};
let Expr::Member(member) = callee_expr.as_ref() else {
return false;
};
if !is_mark_prop(&member.prop) || mark_call.args.len() != 1 {
return false;
}
matches!(mark_call.args[0].expr.as_ref(), Expr::Fn(fn_expr) if fn_expr.function.params.is_empty())
}
_ => false,
}
}
fn try_transform_async_to_generator_expr(
expr: Expr,
async_to_gen_callees: &AsyncToGenCallees,
generator_helpers: &[BindingKey],
) -> Option<(Expr, Option<BindingKey>)> {
let Expr::Call(mut call) = expr else {
return None;
};
if call.args.len() != 1 {
return None;
}
let callee = call.callee.as_expr()?;
if !is_async_to_gen_callee(callee, async_to_gen_callees) {
return None;
}
let gen_fn_arg = *call.args.remove(0).expr;
let (mut fn_expr, mark_key) = build_async_fn_expr_from_gen_arg(gen_fn_arg, generator_helpers)?;
let body = fn_expr.function.body.as_mut()?;
replace_yield_with_await(&mut body.stmts);
fn_expr.function.is_async = true;
fn_expr.function.is_generator = false;
Some((Expr::Fn(fn_expr), mark_key))
}
fn build_async_fn_expr_from_gen_arg(
gen_fn_arg: Expr,
generator_helpers: &[BindingKey],
) -> Option<(FnExpr, Option<BindingKey>)> {
match gen_fn_arg {
Expr::Fn(fn_expr) => {
let mut function = *fn_expr.function;
let mark_key = if function.is_generator {
None
} else {
let body = function.body.as_mut()?;
if let Some(mark_key) = try_transform_regenerator_wrap(body) {
mark_key
} else if try_transform_ts_generator_body(body, generator_helpers) {
None
} else {
return None;
}
};
Some((
FnExpr {
ident: fn_expr.ident,
function: Box::new(function),
},
mark_key,
))
}
Expr::Call(mark_call) => {
let callee_expr = mark_call.callee.as_expr()?;
let Expr::Member(member) = callee_expr.as_ref() else {
return None;
};
if !is_mark_prop(&member.prop) || mark_call.args.len() != 1 {
return None;
}
let Expr::Fn(fn_expr) = *mark_call.args.into_iter().next()?.expr else {
return None;
};
let mut function = *fn_expr.function;
let mark_key = if function.is_generator {
None
} else {
let body = function.body.as_mut()?;
if let Some(mark_key) = try_transform_regenerator_wrap(body) {
mark_key
} else if try_transform_ts_generator_body(body, generator_helpers) {
None
} else {
return None;
}
};
Some((
FnExpr {
ident: fn_expr.ident,
function: Box::new(function),
},
mark_key,
))
}
_ => None,
}
}
fn try_transform_async_to_generator(
body: &mut BlockStmt,
async_to_gen_callees: &AsyncToGenCallees,
generator_helpers: &[BindingKey],
_unresolved_mark: Mark,
) -> bool {
let return_idx = body
.stmts
.iter()
.position(|s| is_async_to_gen_return(s, async_to_gen_callees));
let return_idx = match return_idx {
Some(i) => i,
None => return false,
};
// Pre-check: validate the pattern is extractable before removing the stmt.
if !can_extract_async_to_gen(&body.stmts[return_idx], generator_helpers) {
return false;
}
let ret_stmt = body.stmts.remove(return_idx);
let inner_stmts =
match extract_async_to_gen_body(ret_stmt, async_to_gen_callees, generator_helpers) {
Some(s) => s,
None => unreachable!("can_extract_async_to_gen passed but extract failed"),
};
let mut inner_stmts = inner_stmts;
replace_yield_with_await(&mut inner_stmts);
body.stmts.splice(return_idx..return_idx, inner_stmts);
true
}
fn is_async_to_gen_return(stmt: &Stmt, async_to_gen_callees: &AsyncToGenCallees) -> bool {
let Stmt::Return(ret) = stmt else {
return false;
};
let Some(arg) = &ret.arg else { return false };
is_async_to_gen_call(arg, async_to_gen_callees)
}
/// Non-destructive check: can we extract the async body from this statement?
/// Validates the same conditions as extract_async_to_gen_body without consuming the AST.
fn can_extract_async_to_gen(stmt: &Stmt, generator_helpers: &[BindingKey]) -> bool {
let Stmt::Return(ret) = stmt else {
return false;
};
let Some(arg) = &ret.arg else { return false };
let Expr::Call(outer_call) = arg.as_ref() else {
return false;
};
// Outer IIFE must have no arguments
if !outer_call.args.is_empty() {
return false;
}
let Some(outer_callee) = outer_call.callee.as_expr() else {
return false;
};
let Expr::Call(inner_call) = outer_callee.as_ref() else {
return false;
};
if inner_call.args.len() != 1 {
return false;
}
let gen_fn = &inner_call.args[0].expr;
match gen_fn.as_ref() {
Expr::Fn(fn_expr) => {
// Inner generator must have no params
if !fn_expr.function.params.is_empty() {
return false;
}
if fn_expr.function.is_generator {
return true;
}
// Non-generator: must contain either regenerator.wrap or SWC's
// _ts_generator state machine.
fn_expr.function.body.as_ref().is_some_and(|body| {
body.stmts
.iter()
.any(|s| is_regenerator_wrap_return(s) && !has_nested_control_flow_in_stmt(s))
|| {
let mut body = body.clone();
try_transform_ts_generator_body(&mut body, generator_helpers)
}
})
}
Expr::Call(mark_call) => {
// regeneratorRuntime.mark(function _callee() { ... })
let Some(callee) = mark_call.callee.as_expr() else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
if !is_mark_prop(&member.prop) || mark_call.args.len() != 1 {
return false;
}
let Expr::Fn(fn_expr) = mark_call.args[0].expr.as_ref() else {
return false;
};
if !fn_expr.function.params.is_empty() {
return false;
}
fn_expr.function.body.as_ref().is_some_and(|body| {
body.stmts
.iter()
.any(|s| is_regenerator_wrap_return(s) && !has_nested_control_flow_in_stmt(s))
|| {
let mut body = body.clone();
try_transform_ts_generator_body(&mut body, generator_helpers)
}
})
}
_ => false,
}
}
/// Check for `_asyncToGenerator(fn)()` — IIFE pattern with scope-aware matching
fn is_async_to_gen_call(expr: &Expr, async_to_gen_callees: &AsyncToGenCallees) -> bool {
let Expr::Call(outer_call) = expr else {
return false;
};
let Some(outer_callee) = outer_call.callee.as_expr() else {
return false;
};
let Expr::Call(inner_call) = outer_callee.as_ref() else {
return false;
};
let Some(inner_callee) = inner_call.callee.as_expr() else {
return false;
};
is_async_to_gen_callee(inner_callee, async_to_gen_callees)
}
fn is_async_to_gen_callee(expr: &Expr, async_to_gen_callees: &AsyncToGenCallees) -> bool {
if let Expr::Ident(id) = expr {
return async_to_gen_callees
.direct
.iter()
.any(|(sym, ctxt)| id.sym == *sym && id.ctxt == *ctxt);
}
let Expr::Member(member) = expr else {
return false;
};
if !member_prop_name(&member.prop, "default") {
return false;
}
let Expr::Ident(obj) = member.obj.as_ref() else {
return false;
};
async_to_gen_callees
.default_members
.iter()
.any(|(sym, ctxt)| obj.sym == *sym && obj.ctxt == *ctxt)
}
fn extract_async_to_gen_body(
stmt: Stmt,
async_to_gen_callees: &AsyncToGenCallees,
generator_helpers: &[BindingKey],
) -> Option<Vec<Stmt>> {
let Stmt::Return(ret) = stmt else { return None };
let arg = *ret.arg?;
// _asyncToGenerator(fn)()
let Expr::Call(outer_call) = arg else {
return None;
};
// P1-2: Bail out if the outer IIFE call has arguments
if !outer_call.args.is_empty() {
return None;
}
let Expr::Call(mut inner_call) = *outer_call.callee.expect_expr() else {
return None;
};
let inner_callee = inner_call.callee.as_expr()?;
if !is_async_to_gen_callee(inner_callee, async_to_gen_callees) {
return None;
}
if inner_call.args.len() != 1 {
return None;
}
let gen_fn_arg = *inner_call.args.remove(0).expr;
// The argument could be:
// 1. function*() { ... } — native generator
// 2. regeneratorRuntime.mark(function _callee() { ... }) — babel wrapped
match gen_fn_arg {
Expr::Fn(fn_expr) => {
// P1-2: Bail out if inner generator has params — real Babel output
// never has params here (they're on the outer function via closure)
if !fn_expr.function.params.is_empty() {
return None;
}
if fn_expr.function.is_generator {
// Native generator: just extract body
return fn_expr.function.body.map(|b| b.stmts);
}
// Non-generator function that contains regeneratorRuntime.wrap
let mut body = fn_expr.function.body?;
if try_transform_regenerator_wrap(&mut body).is_some()
|| try_transform_ts_generator_body(&mut body, generator_helpers)
{
return Some(body.stmts);
}
None
}
Expr::Call(mark_call) => {
// regeneratorRuntime.mark(function _callee() { ... })
let callee_expr = mark_call.callee.as_expr()?;
let Expr::Member(member) = callee_expr.as_ref() else {
return None;
};
if !is_mark_prop(&member.prop) {
return None;
}
if mark_call.args.len() != 1 {
return None;
}
let inner_fn = *mark_call.args.into_iter().next()?.expr;
let Expr::Fn(fn_expr) = inner_fn else {
return None;
};
let mut body = fn_expr.function.body?;
if try_transform_regenerator_wrap(&mut body).is_some()
|| try_transform_ts_generator_body(&mut body, generator_helpers)
{
return Some(body.stmts);
}
None
}
_ => None,
}
}
fn replace_yield_with_await(stmts: &mut Vec<Stmt>) {
struct YieldToAwait;
impl VisitMut for YieldToAwait {
fn visit_mut_function(&mut self, _func: &mut Function) {}
fn visit_mut_arrow_expr(&mut self, _arrow: &mut ArrowExpr) {}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if let Expr::Yield(y) = expr {
let yield_span = y.span;
let arg = y.arg.take().unwrap_or_else(|| {
Box::new(Expr::Ident(Ident::new_no_ctxt(
"undefined".into(),
DUMMY_SP,
)))
});
*expr = Expr::Await(AwaitExpr {
span: yield_span,
arg,
});
expr.visit_mut_children_with(self);
return;
}
expr.visit_mut_children_with(self);
}
}
let mut v = YieldToAwait;
for s in stmts.iter_mut() {
s.visit_mut_with(&mut v);
}
}
// ============================================================
// Module-level cleanup: remove regeneratorRuntime.mark() decls
// ============================================================
/// Remove only the mark declarations whose bindings were consumed by
/// successful `.wrap()` transforms. Only removes `var x = <expr>.mark(fn)`
/// where `(x.sym, x.ctxt)` matches a consumed mark key.
fn remove_consumed_mark_declarations(module: &mut Module, consumed_marks: &[BindingKey]) {
if consumed_marks.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(bi) = &decl.name else {
return true;
};
if !consumed_marks
.iter()
.any(|(sym, ctxt)| bi.id.sym == *sym && bi.id.ctxt == *ctxt)
{
return true;
}
// Only remove if the initializer is a .mark() call
let Some(init) = &decl.init else {
return true;
};
let Expr::Call(call) = init.as_ref() else {
return true;
};
let Some(callee) = call.callee.as_expr() else {
return true;
};
let Expr::Member(member) = callee.as_ref() else {
return true;
};
!is_mark_prop(&member.prop)
});
!var.decls.is_empty()
});
}
fn remove_helper_decls(module: &mut Module, to_remove: &[BindingKey]) {
let removable: HashSet<BindingKey> = to_remove.iter().cloned().collect();
remove_fn_decls_by_binding(module, &removable);
remove_var_declarators_by_binding(&mut module.body, &removable);
}
fn remove_unused_helper_decls(module: &mut Module, helpers: &[BindingKey]) {
if helpers.is_empty() {
return;
}
let unused: Vec<_> = helpers
.iter()
.filter(|helper| count_binding_refs(module, helper) <= 1)
.cloned()
.collect();
remove_helper_decls(module, &unused);
}
// ============================================================
// Shared helpers
// ============================================================
/// Set the span on the outermost node of a replacement expression, covering the
/// expr types this rule produces at replacement sites. Only touches the outer
/// wrapper -- inner sub-nodes keep their original (or DUMMY) spans.
fn propagate_span(expr: &mut Expr, span: Span) {
if span.lo.0 == 0 {
return;
}
match expr {
Expr::Call(e) => e.span = span,
Expr::Fn(e) => e.function.span = span,
Expr::Await(e) => e.span = span,
Expr::Yield(e) => e.span = span,
Expr::Paren(e) => e.span = span,
Expr::Member(e) => e.span = span,
_ => {}
}
}
fn is_ident_with_name(expr: &Expr, name: &Atom) -> bool {
matches!(expr, Expr::Ident(id) if id.sym == *name)
}
fn member_prop_atom(prop: &MemberProp) -> Option<Atom> {
match prop {
MemberProp::Ident(id) => Some(id.sym.clone()),
MemberProp::Computed(c) => {
if let Expr::Lit(Lit::Str(s)) = c.expr.as_ref() {
s.value.as_str().map(Atom::from)
} else {
None
}
}
_ => None,
}
}
fn is_number_lit(expr: &Expr, expected: f64) -> bool {
matches!(strip_parens(expr), Expr::Lit(Lit::Num(num)) if num.value == expected)
}
fn number_lit_usize(expr: &Expr) -> Option<usize> {
let Expr::Lit(Lit::Num(num)) = strip_parens(expr) else {
return None;
};
Some(num.value as usize)
}
fn export_name_is(name: &swc_core::ecma::ast::ModuleExportName, expected: &str) -> bool {
match name {
swc_core::ecma::ast::ModuleExportName::Ident(id) => id.sym.as_ref() == expected,
swc_core::ecma::ast::ModuleExportName::Str(s) => s.value.as_str() == Some(expected),
}
}
fn str_to_atom(value: &swc_core::atoms::Wtf8Atom) -> Atom {
Atom::from(value.as_str().unwrap_or(""))
}