crates/core/src/facts.rs
GitHub//! Post-Stage-2 fact extraction.
//!
//! After Stage 2 (helper unwrapping + module-system reconstruction), the AST has
//! clean `import`/`export` declarations. This module extracts a per-module fact
//! summary from that reconstructed form.
//!
//! These facts are the foundation for cross-module analysis in the multi-module
//! `unpack()` path. Single-file `decompile()` does not use them.
use std::{
collections::{HashMap, HashSet},
fmt,
};
use swc_core::atoms::Atom;
use swc_core::ecma::ast::{
ArrowExpr, AssignExpr, AssignOp, AssignTarget, BlockStmtOrExpr, Callee, Decl, DefaultDecl,
ExportSpecifier, Expr, Function, ImportSpecifier, Lit, MemberExpr, MemberProp, Module,
ModuleDecl, ModuleItem, Prop, PropName, PropOrSpread, ReturnStmt, SimpleAssignTarget, Stmt,
VarDeclarator,
};
use swc_core::ecma::visit::{Visit, VisitWith};
use crate::module_path::resolve_relative_specifier;
use crate::rules::helper_matcher::{
binding_key, binding_key_from_ident_pat, expr_matches_binding, BindingKey,
};
use crate::rules::transpiler_helper_utils::{
collect_inline_ts_helpers_deep, collect_transpiler_helpers, LocalHelperContext,
TranspilerHelperKind, TsHelperKind,
};
use crate::utils::paren::strip_parens;
/// How a binding was imported.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ImportKind {
/// `import x from "..."`
Default,
/// `import * as x from "..."`
Namespace,
/// `import { foo } from "..."` or `import { foo as bar } from "..."`
Named(Atom),
}
/// One import binding extracted from the post-Stage-2 AST.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ImportFact {
/// The local binding name (what the module uses internally).
pub local: Atom,
/// The module specifier.
pub source: Atom,
/// How it was imported.
pub kind: ImportKind,
}
/// How a binding was exported.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExportKind {
/// `export default ...`
Default,
/// `export function foo() {}`, `export const foo = ...`, or `export { foo }`
Named,
}
/// One export extracted from the post-Stage-2 AST.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExportFact {
/// The exported name (what consumers import by).
/// `"default"` for default exports.
pub exported: Atom,
/// The local binding name, if any.
/// For `export { foo as bar }`, local is `foo` and exported is `bar`.
/// For `export default expr`, local is `None`.
pub local: Option<Atom>,
/// How it was exported.
pub kind: ExportKind,
}
/// Transpiler/runtime helper identity proven from a module's exported AST shape.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HelperKind {
InteropRequireDefault,
InteropRequireWildcard,
ToConsumableArray,
Extends,
ObjectSpread,
SlicedToArray,
ClassCallCheck,
PossibleConstructorReturn,
AssertThisInitialized,
ObjectWithoutProperties,
Inherits,
CallSuper,
AsyncToGenerator,
TaggedTemplateLiteral,
RegeneratorRuntime,
}
/// Raw TypeScript/tslib helper identity proven from a module's exported AST shape.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TypeScriptHelperKind {
Awaiter,
Generator,
Values,
Assign,
Rest,
Extends,
ImportDefault,
ImportStar,
CreateBinding,
SetModuleDefault,
Read,
Spread,
SpreadArrays,
SpreadArray,
ClassPrivateFieldGet,
ClassPrivateFieldSet,
}
/// One helper export extracted from the post-Stage-2 AST.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HelperExportFact {
/// The exported name that consumers import/access.
/// `"default"` for default exports.
pub exported: Atom,
/// The local binding name, if any.
pub local: Option<Atom>,
/// The proven helper/runtime identity.
pub kind: HelperKind,
}
/// One raw TypeScript/tslib helper export extracted from the post-Stage-2 AST.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TypeScriptHelperExportFact {
/// The exported name that consumers import/access.
/// `"default"` for default exports.
pub exported: Atom,
/// The local binding name, if any.
pub local: Option<Atom>,
/// The proven TypeScript/tslib helper identity.
pub kind: TypeScriptHelperKind,
}
/// Facts extracted from one module after Stage 2.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ModuleFacts {
pub imports: Vec<ImportFact>,
pub exports: Vec<ExportFact>,
pub helper_exports: Vec<HelperExportFact>,
pub default_object_helper_exports: Vec<HelperExportFact>,
pub ts_helper_exports: Vec<TypeScriptHelperExportFact>,
/// Exported zero-argument functions proven to return a CommonJS namespace
/// object containing registered TypeScript helpers.
pub ts_helper_namespace_factory_exports: Vec<Atom>,
/// If this module is a passthrough re-export (`export default require("./X.js")`),
/// this is the target module specifier. Importers can be redirected to the target.
pub passthrough_target: Option<Atom>,
/// True when the module exports a recognized transpiler helper (Babel/tslib),
/// including helper-dependency kinds with no rewrite mapping (e.g.
/// `_defineProperty`). Used by dead-module elimination to treat the module as
/// removable boilerplate.
pub is_helper_module: bool,
}
/// Cross-module fact storage with normalized module key lookup.
///
/// Module specifiers come in several forms — `"./lib/foo.js"`, `"lib/foo.js"`,
/// `"lib/foo"` — but must all resolve to the same module. This map stores facts
/// under a canonical key and provides lookup that handles common variants.
///
/// Canonical form: no leading `./`, preserves the rest (e.g. `"lib/foo.js"`).
#[derive(Debug, Clone, Default)]
pub struct ModuleFactsMap {
inner: std::collections::HashMap<String, ModuleFacts>,
}
impl ModuleFactsMap {
pub fn new() -> Self {
Self::default()
}
/// Insert facts for a module. The key is normalized to canonical form.
pub fn insert(&mut self, key: &str, facts: ModuleFacts) {
self.inner.insert(Self::canonicalize(key), facts);
}
/// Look up facts by module specifier. Tries the specifier as-is, then
/// common variants (with/without `./`, with/without `.js`).
pub fn get(&self, specifier: &str) -> Option<&ModuleFacts> {
self.resolve_key(specifier)
.and_then(|key| self.inner.get(key.as_str()))
}
/// Look up facts for a specifier as written by a specific importing module.
/// Relative sources are resolved from `from_filename` before common lookup
/// variants are tried.
pub fn get_from(&self, from_filename: Option<&str>, specifier: &str) -> Option<&ModuleFacts> {
self.resolve_key_from(from_filename, specifier)
.and_then(|key| self.inner.get(key.as_str()))
}
/// Resolve a specifier to the canonical key stored in this map.
pub fn resolve_key(&self, specifier: &str) -> Option<String> {
self.resolve_key_from(None, specifier)
}
/// Resolve a specifier as written by a specific importing module to the
/// canonical key stored in this map.
pub fn resolve_key_from(&self, from_filename: Option<&str>, specifier: &str) -> Option<String> {
if let Some(from_filename) = from_filename {
if let Some(resolved) = resolve_relative_specifier(from_filename, specifier) {
if let Some(key) = self.resolve_key_exact_variants(&resolved) {
return Some(key);
}
}
}
self.resolve_key_exact_variants(specifier)
}
fn resolve_key_exact_variants(&self, specifier: &str) -> Option<String> {
let canon = Self::canonicalize(specifier);
// Try canonical form first
if self.inner.contains_key(&canon) {
return Some(canon);
}
// Try common extensions added
let has_ext = [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]
.iter()
.any(|ext| canon.ends_with(ext));
if !has_ext {
for ext in [".js", ".jsx"] {
let with_ext = format!("{canon}{ext}");
if self.inner.contains_key(&with_ext) {
return Some(with_ext);
}
}
}
// Try with extension stripped
for ext in [".js", ".jsx"] {
if let Some(stripped) = canon.strip_suffix(ext) {
if self.inner.contains_key(stripped) {
return Some(stripped.to_string());
}
}
}
None
}
/// Number of modules in the map.
pub fn len(&self) -> usize {
self.inner.len()
}
/// Whether the map is empty.
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
/// Normalize a module specifier to canonical form.
/// Strips leading `./` — the canonical key is always a relative path
/// without the dot-slash prefix.
fn canonicalize(specifier: &str) -> String {
specifier
.strip_prefix("./")
.unwrap_or(specifier)
.to_string()
}
}
impl fmt::Display for ModuleFactsMap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut keys: Vec<&String> = self.inner.keys().collect();
keys.sort();
for (i, key) in keys.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
let facts = &self.inner[*key];
write!(f, "── {key} ──\n{facts}")?;
}
Ok(())
}
}
// ── Display implementations for debugging/inspection ───────────────
impl fmt::Display for ImportKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ImportKind::Default => write!(f, "default"),
ImportKind::Namespace => write!(f, "namespace"),
ImportKind::Named(name) => write!(f, "named({name})"),
}
}
}
impl fmt::Display for ExportKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ExportKind::Default => write!(f, "default"),
ExportKind::Named => write!(f, "named"),
}
}
}
impl fmt::Display for HelperKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
HelperKind::InteropRequireDefault => write!(f, "interopRequireDefault"),
HelperKind::InteropRequireWildcard => write!(f, "interopRequireWildcard"),
HelperKind::ToConsumableArray => write!(f, "toConsumableArray"),
HelperKind::Extends => write!(f, "extends"),
HelperKind::ObjectSpread => write!(f, "objectSpread"),
HelperKind::SlicedToArray => write!(f, "slicedToArray"),
HelperKind::ClassCallCheck => write!(f, "classCallCheck"),
HelperKind::PossibleConstructorReturn => write!(f, "possibleConstructorReturn"),
HelperKind::AssertThisInitialized => write!(f, "assertThisInitialized"),
HelperKind::ObjectWithoutProperties => write!(f, "objectWithoutProperties"),
HelperKind::Inherits => write!(f, "inherits"),
HelperKind::CallSuper => write!(f, "callSuper"),
HelperKind::AsyncToGenerator => write!(f, "asyncToGenerator"),
HelperKind::TaggedTemplateLiteral => write!(f, "taggedTemplateLiteral"),
HelperKind::RegeneratorRuntime => write!(f, "regeneratorRuntime"),
}
}
}
impl fmt::Display for TypeScriptHelperKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TypeScriptHelperKind::Awaiter => write!(f, "ts:awaiter"),
TypeScriptHelperKind::Generator => write!(f, "ts:generator"),
TypeScriptHelperKind::Values => write!(f, "ts:values"),
TypeScriptHelperKind::Assign => write!(f, "ts:assign"),
TypeScriptHelperKind::Rest => write!(f, "ts:rest"),
TypeScriptHelperKind::Extends => write!(f, "ts:extends"),
TypeScriptHelperKind::ImportDefault => write!(f, "ts:importDefault"),
TypeScriptHelperKind::ImportStar => write!(f, "ts:importStar"),
TypeScriptHelperKind::CreateBinding => write!(f, "ts:createBinding"),
TypeScriptHelperKind::SetModuleDefault => write!(f, "ts:setModuleDefault"),
TypeScriptHelperKind::Read => write!(f, "ts:read"),
TypeScriptHelperKind::Spread => write!(f, "ts:spread"),
TypeScriptHelperKind::SpreadArrays => write!(f, "ts:spreadArrays"),
TypeScriptHelperKind::SpreadArray => write!(f, "ts:spreadArray"),
TypeScriptHelperKind::ClassPrivateFieldGet => write!(f, "ts:classPrivateFieldGet"),
TypeScriptHelperKind::ClassPrivateFieldSet => write!(f, "ts:classPrivateFieldSet"),
}
}
}
impl fmt::Display for ImportFact {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"import {} from \"{}\" [{}]",
self.local, self.source, self.kind
)
}
}
impl fmt::Display for ExportFact {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.local {
Some(local) if local.as_ref() != self.exported.as_ref() => {
write!(f, "export {} as {} [{}]", local, self.exported, self.kind)
}
_ => write!(f, "export {} [{}]", self.exported, self.kind),
}
}
}
impl fmt::Display for HelperExportFact {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.local {
Some(local) if local.as_ref() != self.exported.as_ref() => {
write!(
f,
"helper export {} as {} [{}]",
local, self.exported, self.kind
)
}
_ => write!(f, "helper export {} [{}]", self.exported, self.kind),
}
}
}
impl fmt::Display for TypeScriptHelperExportFact {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.local {
Some(local) if local.as_ref() != self.exported.as_ref() => {
write!(
f,
"ts helper export {} as {} [{}]",
local, self.exported, self.kind
)
}
_ => write!(f, "ts helper export {} [{}]", self.exported, self.kind),
}
}
}
impl fmt::Display for ModuleFacts {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.imports.is_empty()
&& self.exports.is_empty()
&& self.helper_exports.is_empty()
&& self.default_object_helper_exports.is_empty()
&& self.ts_helper_exports.is_empty()
&& self.ts_helper_namespace_factory_exports.is_empty()
{
return write!(f, "(no imports or exports)");
}
for (i, import) in self.imports.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
write!(f, "{import}")?;
}
if !self.imports.is_empty() && !self.exports.is_empty() {
writeln!(f)?;
}
for (i, export) in self.exports.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
write!(f, "{export}")?;
}
if (!self.imports.is_empty() || !self.exports.is_empty()) && !self.helper_exports.is_empty()
{
writeln!(f)?;
}
for (i, helper) in self.helper_exports.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
write!(f, "{helper}")?;
}
if (!self.imports.is_empty() || !self.exports.is_empty() || !self.helper_exports.is_empty())
&& !self.default_object_helper_exports.is_empty()
{
writeln!(f)?;
}
for (i, helper) in self.default_object_helper_exports.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
write!(f, "default object {helper}")?;
}
if (!self.imports.is_empty()
|| !self.exports.is_empty()
|| !self.helper_exports.is_empty()
|| !self.default_object_helper_exports.is_empty())
&& !self.ts_helper_exports.is_empty()
{
writeln!(f)?;
}
for (i, helper) in self.ts_helper_exports.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
write!(f, "{helper}")?;
}
if !self.ts_helper_namespace_factory_exports.is_empty() {
if !self.imports.is_empty()
|| !self.exports.is_empty()
|| !self.helper_exports.is_empty()
|| !self.default_object_helper_exports.is_empty()
|| !self.ts_helper_exports.is_empty()
{
writeln!(f)?;
}
for (i, factory) in self.ts_helper_namespace_factory_exports.iter().enumerate() {
if i > 0 {
writeln!(f)?;
}
write!(f, "ts helper namespace factory export {factory}")?;
}
}
Ok(())
}
}
/// Extract import/export facts from a module AST that has completed Stage 2.
///
/// This collector reads the reconstructed ESM declarations produced by `UnEsm`
/// and the helper unwrapping rules. It should be called immediately after Stage 2,
/// before later rules modify the import/export structure.
pub fn collect_module_facts(module: &Module) -> ModuleFacts {
let mut facts = ModuleFacts::default();
for item in &module.body {
let ModuleItem::ModuleDecl(decl) = item else {
continue;
};
match decl {
ModuleDecl::Import(import) => {
if import.type_only {
continue;
}
let source = str_to_atom(&import.src.value);
for spec in &import.specifiers {
let (local, kind) = match spec {
ImportSpecifier::Default(s) => (s.local.sym.clone(), ImportKind::Default),
ImportSpecifier::Namespace(s) => {
(s.local.sym.clone(), ImportKind::Namespace)
}
ImportSpecifier::Named(s) => {
let imported_name = s
.imported
.as_ref()
.map(export_name_to_atom)
.unwrap_or_else(|| s.local.sym.clone());
(s.local.sym.clone(), ImportKind::Named(imported_name))
}
};
facts.imports.push(ImportFact {
local,
source: source.clone(),
kind,
});
}
}
ModuleDecl::ExportDefaultDecl(export) => {
let local = match &export.decl {
DefaultDecl::Fn(f) => f.ident.as_ref().map(|id| id.sym.clone()),
DefaultDecl::Class(c) => c.ident.as_ref().map(|id| id.sym.clone()),
DefaultDecl::TsInterfaceDecl(_) => None,
};
facts.exports.push(ExportFact {
exported: "default".into(),
local,
kind: ExportKind::Default,
});
}
ModuleDecl::ExportDefaultExpr(export) => {
let local = match export.expr.as_ref() {
Expr::Ident(ident) => Some(ident.sym.clone()),
_ => None,
};
facts.exports.push(ExportFact {
exported: "default".into(),
local,
kind: ExportKind::Default,
});
}
ModuleDecl::ExportDecl(export) => match &export.decl {
Decl::Var(var) => {
for decl in &var.decls {
if let swc_core::ecma::ast::Pat::Ident(binding) = &decl.name {
facts.exports.push(ExportFact {
exported: binding.id.sym.clone(),
local: Some(binding.id.sym.clone()),
kind: ExportKind::Named,
});
}
}
}
Decl::Fn(f) => {
facts.exports.push(ExportFact {
exported: f.ident.sym.clone(),
local: Some(f.ident.sym.clone()),
kind: ExportKind::Named,
});
}
Decl::Class(c) => {
facts.exports.push(ExportFact {
exported: c.ident.sym.clone(),
local: Some(c.ident.sym.clone()),
kind: ExportKind::Named,
});
}
_ => {}
},
ModuleDecl::ExportNamed(named) => {
for spec in &named.specifiers {
match spec {
ExportSpecifier::Named(s) => {
let local_name = export_name_to_atom(&s.orig);
let exported_name = s
.exported
.as_ref()
.map(export_name_to_atom)
.unwrap_or_else(|| local_name.clone());
let kind = if exported_name.as_ref() == "default" {
ExportKind::Default
} else {
ExportKind::Named
};
facts.exports.push(ExportFact {
exported: exported_name,
local: named.src.is_none().then_some(local_name),
kind,
});
}
ExportSpecifier::Default(s) => {
facts.exports.push(ExportFact {
exported: "default".into(),
local: Some(s.exported.sym.clone()),
kind: ExportKind::Default,
});
}
ExportSpecifier::Namespace(s) => {
facts.exports.push(ExportFact {
exported: export_name_to_atom(&s.name),
local: None,
kind: ExportKind::Named,
});
}
}
}
}
ModuleDecl::ExportAll(_) => {
// `export * from "..."` — not enumerable locally, skip for v1
}
_ => {}
}
}
facts.passthrough_target = detect_passthrough(module);
let (helper_exports, exports_any_helper) = collect_helper_exports(module, &facts.exports);
facts.helper_exports = helper_exports;
facts.default_object_helper_exports = collect_default_object_helper_exports(module);
facts.ts_helper_exports = collect_ts_helper_exports(module, &facts.exports);
facts.ts_helper_namespace_factory_exports = collect_ts_helper_namespace_factory_exports(module);
facts.is_helper_module = exports_any_helper
|| !facts.default_object_helper_exports.is_empty()
|| !facts.ts_helper_exports.is_empty();
facts
}
fn collect_ts_helper_namespace_factory_exports(module: &Module) -> Vec<Atom> {
module
.body
.iter()
.filter_map(|item| {
let ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) = item else {
return None;
};
let Decl::Fn(function) = &export.decl else {
return None;
};
let body = function.function.body.as_ref()?;
if !function.function.params.is_empty() || !body_returns_cjs_namespace(&body.stmts) {
return None;
}
let nested = Module {
span: body.span,
body: body.stmts.iter().cloned().map(ModuleItem::Stmt).collect(),
shebang: None,
};
(!collect_ts_helper_exports(&nested, &[]).is_empty())
.then(|| function.ident.sym.clone())
})
.collect()
}
fn body_returns_cjs_namespace(stmts: &[Stmt]) -> bool {
let mut namespace_objects = HashSet::new();
let mut declared_bindings = HashSet::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for declarator in &var.decls {
let Some(binding) = binding_key_from_ident_pat(&declarator.name) else {
continue;
};
declared_bindings.insert(binding.clone());
if matches!(declarator.init.as_deref().map(strip_parens), Some(Expr::Object(object)) if object.props.is_empty())
{
namespace_objects.insert(binding);
}
}
}
let mut module_objects = HashSet::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for declarator in &var.decls {
let Some(binding) = binding_key_from_ident_pat(&declarator.name) else {
continue;
};
let Some(Expr::Object(object)) = declarator.init.as_deref().map(strip_parens) else {
continue;
};
let [PropOrSpread::Prop(prop)] = object.props.as_slice() else {
continue;
};
let Prop::KeyValue(property) = prop.as_ref() else {
continue;
};
if static_prop_name(&property.key) != Some("exports") {
continue;
}
let Expr::Ident(exports) = strip_parens(property.value.as_ref()) else {
continue;
};
if namespace_objects.contains(&binding_key(exports)) {
module_objects.insert(binding);
}
}
}
stmts.iter().any(|stmt| {
let Stmt::Return(ReturnStmt { arg: Some(arg), .. }) = stmt else {
return false;
};
match strip_parens(arg.as_ref()) {
Expr::Ident(id) => {
namespace_objects.contains(&binding_key(id))
|| (id.sym.as_ref() == "exports"
&& !declared_bindings.iter().any(|(name, _)| name == &id.sym))
}
Expr::Member(member) => {
static_member_prop_name(&member.prop) == Some("exports")
&& matches!(strip_parens(member.obj.as_ref()), Expr::Ident(id)
if module_objects.contains(&binding_key(id))
|| (id.sym.as_ref() == "module"
&& !declared_bindings.iter().any(|(name, _)| name == &id.sym)))
}
_ => false,
}
})
}
fn static_prop_name(name: &PropName) -> Option<&str> {
match name {
PropName::Ident(id) => Some(id.sym.as_ref()),
PropName::Str(value) => value.value.as_str(),
_ => None,
}
}
/// Returns the rewrite-relevant helper exports plus whether the module exports
/// *any* recognized transpiler helper. The second value also covers helper kinds
/// that have no rewrite mapping (`DefineProperty`, `Typeof`, `HelperDependency`),
/// so a helper-dependency module like `_defineProperty` — which other helpers
/// import — is still identifiable as helper boilerplate.
fn collect_helper_exports(
module: &Module,
exports: &[ExportFact],
) -> (Vec<HelperExportFact>, bool) {
let local_helpers = collect_transpiler_helpers(module);
let mut helper_exports = Vec::new();
let mut exports_any_helper = false;
for export in exports {
let Some(local) = &export.local else {
continue;
};
let matches_transpiler = local_helpers.iter().any(|((sym, _), _)| sym == local);
let kind = local_helpers
.iter()
.find_map(|((sym, _), kind)| {
(sym == local)
.then(|| helper_kind_from_transpiler(*kind))
.flatten()
})
.or_else(|| {
is_regenerator_runtime_binding(module, local)
.then_some(HelperKind::RegeneratorRuntime)
});
if matches_transpiler || kind.is_some() {
exports_any_helper = true;
}
if let Some(kind) = kind {
helper_exports.push(HelperExportFact {
exported: export.exported.clone(),
local: Some(local.clone()),
kind,
});
}
}
(helper_exports, exports_any_helper)
}
fn collect_ts_helper_exports(
module: &Module,
exports: &[ExportFact],
) -> Vec<TypeScriptHelperExportFact> {
let local_helpers = LocalHelperContext::collect(module);
let deep_inline_helpers = collect_inline_ts_helpers_deep(module);
let mut helper_exports = Vec::new();
for export in exports {
let Some(local) = &export.local else {
continue;
};
let kind = local_helpers
.ts_helper_kind_by_symbol(local)
.map(helper_kind_from_ts)
.or_else(|| {
local_helpers.helpers().iter().find_map(|((sym, _), kind)| {
(sym == local)
.then(|| helper_kind_from_transpiler_ts(*kind))
.flatten()
})
});
let Some(kind) = kind else {
continue;
};
push_ts_helper_export(
&mut helper_exports,
export.exported.clone(),
Some(local.clone()),
kind,
);
}
collect_registered_ts_helper_exports(module, &deep_inline_helpers, &mut helper_exports);
helper_exports
}
fn helper_kind_from_transpiler_ts(kind: TranspilerHelperKind) -> Option<TypeScriptHelperKind> {
match kind {
TranspilerHelperKind::ObjectWithoutProperties => Some(TypeScriptHelperKind::Rest),
_ => None,
}
}
fn collect_registered_ts_helper_exports(
module: &Module,
inline_helpers: &HashMap<BindingKey, TsHelperKind>,
helper_exports: &mut Vec<TypeScriptHelperExportFact>,
) {
let registrars = collect_ts_helper_export_registrars(module);
struct RegistrarExportCollector<'a, 'b> {
inline_helpers: &'a HashMap<BindingKey, TsHelperKind>,
registrars: &'a HashSet<BindingKey>,
helper_exports: &'b mut Vec<TypeScriptHelperExportFact>,
}
impl Visit for RegistrarExportCollector<'_, '_> {
fn visit_call_expr(&mut self, call: &swc_core::ecma::ast::CallExpr) {
if !is_ts_helper_export_registration_call(call, self.registrars) {
call.visit_children_with(self);
return;
}
let [export_arg, local_arg] = call.args.as_slice() else {
call.visit_children_with(self);
return;
};
if export_arg.spread.is_some() || local_arg.spread.is_some() {
call.visit_children_with(self);
return;
}
let Expr::Lit(Lit::Str(exported)) = export_arg.expr.as_ref() else {
call.visit_children_with(self);
return;
};
let Expr::Ident(local) = local_arg.expr.as_ref() else {
call.visit_children_with(self);
return;
};
let Some(exported_name) = exported.value.as_str() else {
call.visit_children_with(self);
return;
};
let Some(exported_kind) = ts_helper_kind_from_name(exported_name) else {
call.visit_children_with(self);
return;
};
let Some(local_kind) = self
.inline_helpers
.get(&binding_key(local))
.copied()
.map(helper_kind_from_ts)
else {
call.visit_children_with(self);
return;
};
if local_kind == exported_kind {
push_ts_helper_export(
self.helper_exports,
str_to_atom(&exported.value),
Some(local.sym.clone()),
local_kind,
);
}
call.visit_children_with(self);
}
}
let mut collector = RegistrarExportCollector {
inline_helpers,
registrars: ®istrars,
helper_exports,
};
module.visit_with(&mut collector);
}
fn collect_ts_helper_export_registrars(module: &Module) -> HashSet<BindingKey> {
struct RegistrarCollector {
registrars: HashSet<BindingKey>,
}
impl Visit for RegistrarCollector {
fn visit_fn_decl(&mut self, fn_decl: &swc_core::ecma::ast::FnDecl) {
if function_is_ts_helper_export_registrar(&fn_decl.function) {
self.registrars.insert(binding_key(&fn_decl.ident));
}
fn_decl.visit_children_with(self);
}
fn visit_var_declarator(&mut self, declarator: &VarDeclarator) {
if declarator
.init
.as_deref()
.is_some_and(expr_is_ts_helper_export_registrar)
{
if let Some(key) = binding_key_from_ident_pat(&declarator.name) {
self.registrars.insert(key);
}
}
declarator.visit_children_with(self);
}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if assign.op == AssignOp::Assign
&& expr_is_ts_helper_export_registrar(strip_parens(assign.right.as_ref()))
{
if let Some(key) = assign_target_binding_key(&assign.left) {
self.registrars.insert(key);
}
}
assign.visit_children_with(self);
}
fn visit_call_expr(&mut self, call: &swc_core::ecma::ast::CallExpr) {
self.registrars
.extend(callback_registrars_from_callable_call(call));
call.visit_children_with(self);
}
}
let mut collector = RegistrarCollector {
registrars: HashSet::new(),
};
module.visit_with(&mut collector);
collector.registrars
}
fn is_ts_helper_export_registration_call(
call: &swc_core::ecma::ast::CallExpr,
registrars: &HashSet<BindingKey>,
) -> bool {
let Callee::Expr(callee) = &call.callee else {
return false;
};
let Expr::Ident(callee) = strip_parens(callee.as_ref()) else {
return false;
};
registrars.contains(&binding_key(callee))
}
fn expr_is_ts_helper_export_registrar(expr: &Expr) -> bool {
match strip_parens(expr) {
Expr::Fn(fn_expr) => function_is_ts_helper_export_registrar(&fn_expr.function),
Expr::Arrow(arrow) => arrow_is_ts_helper_export_registrar(arrow),
_ => false,
}
}
fn function_is_ts_helper_export_registrar(function: &Function) -> bool {
if function.params.len() < 2 {
return false;
}
let Some(name_key) = binding_key_from_ident_pat(&function.params[0].pat) else {
return false;
};
let Some(value_key) = binding_key_from_ident_pat(&function.params[1].pat) else {
return false;
};
let Some(body) = &function.body else {
return false;
};
body_writes_helper_export(&body.stmts, &name_key, &value_key)
}
fn arrow_is_ts_helper_export_registrar(arrow: &ArrowExpr) -> bool {
if arrow.params.len() < 2 {
return false;
}
let Some(name_key) = binding_key_from_ident_pat(&arrow.params[0]) else {
return false;
};
let Some(value_key) = binding_key_from_ident_pat(&arrow.params[1]) else {
return false;
};
match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(body) => {
body_writes_helper_export(&body.stmts, &name_key, &value_key)
}
BlockStmtOrExpr::Expr(expr) => expr_writes_helper_export(expr, &name_key, &value_key),
}
}
fn callback_registrars_from_callable_call(
call: &swc_core::ecma::ast::CallExpr,
) -> HashSet<BindingKey> {
let Callee::Expr(callee) = &call.callee else {
return HashSet::new();
};
let Some(params) = callable_param_keys(strip_parens(callee.as_ref())) else {
return HashSet::new();
};
let mut registrars = HashSet::new();
for (index, arg) in call.args.iter().enumerate() {
if arg.spread.is_some() {
continue;
}
let Some(callback_param) = callback_registrar_param(arg.expr.as_ref()) else {
continue;
};
let Some(Some(param)) = params.get(index) else {
continue;
};
if callable_passes_registrar_to_param(strip_parens(callee.as_ref()), param) {
registrars.insert(callback_param);
}
}
registrars
}
fn callable_param_keys(expr: &Expr) -> Option<Vec<Option<BindingKey>>> {
match expr {
Expr::Fn(fn_expr) => Some(
fn_expr
.function
.params
.iter()
.map(|param| binding_key_from_ident_pat(¶m.pat))
.collect(),
),
Expr::Arrow(arrow) => Some(
arrow
.params
.iter()
.map(binding_key_from_ident_pat)
.collect(),
),
_ => None,
}
}
fn callback_registrar_param(expr: &Expr) -> Option<BindingKey> {
match strip_parens(expr) {
Expr::Fn(fn_expr) => fn_expr
.function
.params
.first()
.and_then(|param| binding_key_from_ident_pat(¶m.pat)),
Expr::Arrow(arrow) => arrow.params.first().and_then(binding_key_from_ident_pat),
_ => None,
}
}
fn callable_passes_registrar_to_param(expr: &Expr, param: &BindingKey) -> bool {
match expr {
Expr::Fn(fn_expr) => fn_expr
.function
.body
.as_ref()
.is_some_and(|body| body_passes_registrar_to_param(&body.stmts, param)),
Expr::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(body) => body_passes_registrar_to_param(&body.stmts, param),
BlockStmtOrExpr::Expr(expr) => expr_passes_registrar_to_param(expr, param),
},
_ => false,
}
}
fn body_passes_registrar_to_param(stmts: &[Stmt], param: &BindingKey) -> bool {
let factories = collect_ts_helper_export_registrar_factories(stmts);
struct RegistrarArgumentFinder<'a> {
param: &'a BindingKey,
factories: &'a HashSet<BindingKey>,
found: bool,
}
impl Visit for RegistrarArgumentFinder<'_> {
fn visit_call_expr(&mut self, call: &swc_core::ecma::ast::CallExpr) {
if self.found {
return;
}
if call_passes_registrar_to_param(call, self.param, self.factories) {
self.found = true;
return;
}
call.visit_children_with(self);
}
fn visit_function(&mut self, _: &Function) {}
fn visit_arrow_expr(&mut self, _: &ArrowExpr) {}
}
let mut finder = RegistrarArgumentFinder {
param,
factories: &factories,
found: false,
};
stmts.visit_with(&mut finder);
finder.found
}
fn expr_passes_registrar_to_param(expr: &Expr, param: &BindingKey) -> bool {
let Expr::Call(call) = strip_parens(expr) else {
return false;
};
call_passes_registrar_to_param(call, param, &HashSet::new())
}
fn call_passes_registrar_to_param(
call: &swc_core::ecma::ast::CallExpr,
param: &BindingKey,
factories: &HashSet<BindingKey>,
) -> bool {
let Callee::Expr(callee) = &call.callee else {
return false;
};
if !expr_matches_binding(strip_parens(callee.as_ref()), param) {
return false;
}
let Some(first_arg) = call.args.first() else {
return false;
};
first_arg.spread.is_none()
&& expr_is_ts_helper_export_registrar_value(first_arg.expr.as_ref(), factories)
}
fn expr_is_ts_helper_export_registrar_value(expr: &Expr, factories: &HashSet<BindingKey>) -> bool {
if expr_is_ts_helper_export_registrar(expr) {
return true;
}
let Expr::Call(call) = strip_parens(expr) else {
return false;
};
let Callee::Expr(callee) = &call.callee else {
return false;
};
match strip_parens(callee.as_ref()) {
Expr::Ident(id) => {
factories.contains(&binding_key(id))
&& factory_call_arguments_are_registrar_safe(call, factories)
}
Expr::Fn(fn_expr) => {
function_returns_ts_helper_export_registrar(&fn_expr.function)
&& factory_call_arguments_are_registrar_safe(call, factories)
}
Expr::Arrow(arrow) => {
arrow_returns_ts_helper_export_registrar(arrow)
&& factory_call_arguments_are_registrar_safe(call, factories)
}
_ => false,
}
}
fn factory_call_arguments_are_registrar_safe(
call: &swc_core::ecma::ast::CallExpr,
factories: &HashSet<BindingKey>,
) -> bool {
call.args.iter().skip(1).all(|arg| {
arg.spread.is_none()
&& expr_is_ts_helper_export_registrar_value(arg.expr.as_ref(), factories)
})
}
fn collect_ts_helper_export_registrar_factories(stmts: &[Stmt]) -> HashSet<BindingKey> {
struct FactoryCollector {
factories: HashSet<BindingKey>,
}
impl Visit for FactoryCollector {
fn visit_fn_decl(&mut self, fn_decl: &swc_core::ecma::ast::FnDecl) {
if function_returns_ts_helper_export_registrar(&fn_decl.function) {
self.factories.insert(binding_key(&fn_decl.ident));
}
}
fn visit_var_declarator(&mut self, declarator: &VarDeclarator) {
if declarator
.init
.as_deref()
.is_some_and(expr_returns_ts_helper_export_registrar)
{
if let Some(key) = binding_key_from_ident_pat(&declarator.name) {
self.factories.insert(key);
}
}
}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if assign.op == AssignOp::Assign
&& expr_returns_ts_helper_export_registrar(strip_parens(assign.right.as_ref()))
{
if let Some(key) = assign_target_binding_key(&assign.left) {
self.factories.insert(key);
}
}
assign.visit_children_with(self);
}
}
let mut collector = FactoryCollector {
factories: HashSet::new(),
};
stmts.visit_with(&mut collector);
collector.factories
}
fn expr_returns_ts_helper_export_registrar(expr: &Expr) -> bool {
match strip_parens(expr) {
Expr::Fn(fn_expr) => function_returns_ts_helper_export_registrar(&fn_expr.function),
Expr::Arrow(arrow) => arrow_returns_ts_helper_export_registrar(arrow),
_ => false,
}
}
fn function_returns_ts_helper_export_registrar(function: &Function) -> bool {
let Some(target_key) = function
.params
.first()
.and_then(|param| binding_key_from_ident_pat(¶m.pat))
else {
return false;
};
let Some(body) = &function.body else {
return false;
};
body.stmts
.iter()
.any(|stmt| return_stmt_returns_target_registrar(stmt, &target_key))
}
fn arrow_returns_ts_helper_export_registrar(arrow: &ArrowExpr) -> bool {
let Some(target_key) = arrow.params.first().and_then(binding_key_from_ident_pat) else {
return false;
};
match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(body) => body
.stmts
.iter()
.any(|stmt| return_stmt_returns_target_registrar(stmt, &target_key)),
BlockStmtOrExpr::Expr(expr) => expr_is_target_ts_helper_export_registrar(expr, &target_key),
}
}
fn return_stmt_returns_target_registrar(stmt: &Stmt, target_key: &BindingKey) -> bool {
let Stmt::Return(ReturnStmt {
arg: Some(expr), ..
}) = stmt
else {
return false;
};
expr_is_target_ts_helper_export_registrar(expr, target_key)
}
fn expr_is_target_ts_helper_export_registrar(expr: &Expr, target_key: &BindingKey) -> bool {
match strip_parens(expr) {
Expr::Fn(fn_expr) => {
function_is_target_ts_helper_export_registrar(&fn_expr.function, target_key)
}
Expr::Arrow(arrow) => arrow_is_target_ts_helper_export_registrar(arrow, target_key),
_ => false,
}
}
fn function_is_target_ts_helper_export_registrar(
function: &Function,
target_key: &BindingKey,
) -> bool {
if function.params.len() < 2 {
return false;
}
let Some(name_key) = binding_key_from_ident_pat(&function.params[0].pat) else {
return false;
};
let Some(value_key) = binding_key_from_ident_pat(&function.params[1].pat) else {
return false;
};
let Some(body) = &function.body else {
return false;
};
body_writes_target_helper_export(&body.stmts, target_key, &name_key, &value_key)
}
fn arrow_is_target_ts_helper_export_registrar(arrow: &ArrowExpr, target_key: &BindingKey) -> bool {
if arrow.params.len() < 2 {
return false;
}
let Some(name_key) = binding_key_from_ident_pat(&arrow.params[0]) else {
return false;
};
let Some(value_key) = binding_key_from_ident_pat(&arrow.params[1]) else {
return false;
};
match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(body) => {
body_writes_target_helper_export(&body.stmts, target_key, &name_key, &value_key)
}
BlockStmtOrExpr::Expr(expr) => {
expr_writes_target_helper_export(expr, target_key, &name_key, &value_key)
}
}
}
fn body_writes_target_helper_export(
stmts: &[Stmt],
target_key: &BindingKey,
name_key: &BindingKey,
value_key: &BindingKey,
) -> bool {
struct TargetExportWriteFinder<'a> {
target_key: &'a BindingKey,
name_key: &'a BindingKey,
value_key: &'a BindingKey,
found: bool,
}
impl Visit for TargetExportWriteFinder<'_> {
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if is_target_helper_export_assignment(
assign,
self.target_key,
self.name_key,
self.value_key,
) {
self.found = true;
return;
}
assign.visit_children_with(self);
}
fn visit_function(&mut self, _: &Function) {}
fn visit_arrow_expr(&mut self, _: &ArrowExpr) {}
}
let mut finder = TargetExportWriteFinder {
target_key,
name_key,
value_key,
found: false,
};
stmts.visit_with(&mut finder);
finder.found
}
fn expr_writes_target_helper_export(
expr: &Expr,
target_key: &BindingKey,
name_key: &BindingKey,
value_key: &BindingKey,
) -> bool {
let Expr::Assign(assign) = strip_parens(expr) else {
return false;
};
is_target_helper_export_assignment(assign, target_key, name_key, value_key)
}
fn is_target_helper_export_assignment(
assign: &AssignExpr,
target_key: &BindingKey,
name_key: &BindingKey,
value_key: &BindingKey,
) -> bool {
if assign.op != AssignOp::Assign || !expr_produces_registered_value(&assign.right, value_key) {
return false;
}
let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left else {
return false;
};
member_of_target_indexed_by(member, target_key, name_key)
}
fn expr_produces_registered_value(expr: &Expr, value_key: &BindingKey) -> bool {
match strip_parens(expr) {
expr if expr_matches_binding(expr, value_key) => true,
Expr::Cond(cond) => {
expr_produces_registered_value(&cond.cons, value_key)
&& expr_produces_registered_value(&cond.alt, value_key)
}
Expr::Call(call) => call.args.iter().any(|arg| {
arg.spread.is_none() && expr_matches_binding(strip_parens(&arg.expr), value_key)
}),
_ => false,
}
}
fn body_writes_helper_export(
stmts: &[swc_core::ecma::ast::Stmt],
name_key: &BindingKey,
value_key: &BindingKey,
) -> bool {
struct ExportWriteFinder<'a> {
name_key: &'a BindingKey,
value_key: &'a BindingKey,
found: bool,
}
impl Visit for ExportWriteFinder<'_> {
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if is_helper_export_assignment(assign, self.name_key, self.value_key) {
self.found = true;
return;
}
assign.visit_children_with(self);
}
fn visit_function(&mut self, _: &Function) {}
fn visit_arrow_expr(&mut self, _: &ArrowExpr) {}
}
let mut finder = ExportWriteFinder {
name_key,
value_key,
found: false,
};
stmts.visit_with(&mut finder);
finder.found
}
fn expr_writes_helper_export(expr: &Expr, name_key: &BindingKey, value_key: &BindingKey) -> bool {
let Expr::Assign(assign) = strip_parens(expr) else {
return false;
};
is_helper_export_assignment(assign, name_key, value_key)
}
fn is_helper_export_assignment(
assign: &AssignExpr,
name_key: &BindingKey,
value_key: &BindingKey,
) -> bool {
if assign.op != AssignOp::Assign
|| !expr_matches_binding(strip_parens(&assign.right), value_key)
{
return false;
}
let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left else {
return false;
};
exports_member_indexed_by(member, name_key)
}
fn exports_member_indexed_by(member: &MemberExpr, name_key: &BindingKey) -> bool {
if !matches!(
&member.prop,
MemberProp::Computed(computed) if expr_matches_binding(strip_parens(&computed.expr), name_key)
) {
return false;
}
is_exports_object(strip_parens(&member.obj))
}
fn member_of_target_indexed_by(
member: &MemberExpr,
target_key: &BindingKey,
name_key: &BindingKey,
) -> bool {
if !matches!(
&member.prop,
MemberProp::Computed(computed) if expr_matches_binding(strip_parens(&computed.expr), name_key)
) {
return false;
}
expr_matches_binding(strip_parens(&member.obj), target_key)
}
fn is_exports_object(expr: &Expr) -> bool {
match strip_parens(expr) {
Expr::Ident(id) => id.sym.as_ref() == "exports",
Expr::Member(member) => {
matches!(strip_parens(&member.obj), Expr::Ident(id) if id.sym.as_ref() == "module")
&& static_member_prop_name(&member.prop) == Some("exports")
}
_ => false,
}
}
fn assign_target_binding_key(target: &AssignTarget) -> Option<BindingKey> {
let AssignTarget::Simple(SimpleAssignTarget::Ident(binding)) = target else {
return None;
};
Some(binding_key(&binding.id))
}
fn static_member_prop_name(prop: &MemberProp) -> Option<&str> {
match prop {
MemberProp::Ident(id) => Some(id.sym.as_ref()),
MemberProp::Computed(computed) => match strip_parens(&computed.expr) {
Expr::Lit(Lit::Str(value)) => value.value.as_str(),
_ => None,
},
MemberProp::PrivateName(_) => None,
}
}
fn push_ts_helper_export(
helper_exports: &mut Vec<TypeScriptHelperExportFact>,
exported: Atom,
local: Option<Atom>,
kind: TypeScriptHelperKind,
) {
if helper_exports
.iter()
.any(|helper| helper.exported == exported && helper.local == local && helper.kind == kind)
{
return;
}
helper_exports.push(TypeScriptHelperExportFact {
exported,
local,
kind,
});
}
fn helper_kind_from_transpiler(kind: TranspilerHelperKind) -> Option<HelperKind> {
match kind {
TranspilerHelperKind::InteropRequireDefault => Some(HelperKind::InteropRequireDefault),
TranspilerHelperKind::InteropRequireWildcard => Some(HelperKind::InteropRequireWildcard),
TranspilerHelperKind::ToConsumableArray => Some(HelperKind::ToConsumableArray),
TranspilerHelperKind::Extends => Some(HelperKind::Extends),
TranspilerHelperKind::ObjectSpread => Some(HelperKind::ObjectSpread),
TranspilerHelperKind::SlicedToArray => Some(HelperKind::SlicedToArray),
TranspilerHelperKind::ClassCallCheck => Some(HelperKind::ClassCallCheck),
TranspilerHelperKind::PossibleConstructorReturn => {
Some(HelperKind::PossibleConstructorReturn)
}
TranspilerHelperKind::AssertThisInitialized => Some(HelperKind::AssertThisInitialized),
TranspilerHelperKind::ObjectWithoutProperties => Some(HelperKind::ObjectWithoutProperties),
TranspilerHelperKind::Inherits => Some(HelperKind::Inherits),
TranspilerHelperKind::CallSuper => Some(HelperKind::CallSuper),
TranspilerHelperKind::AsyncToGenerator => Some(HelperKind::AsyncToGenerator),
TranspilerHelperKind::TaggedTemplateLiteral => Some(HelperKind::TaggedTemplateLiteral),
TranspilerHelperKind::Typeof => None,
TranspilerHelperKind::DefineProperty => None,
TranspilerHelperKind::CreateClass => None,
TranspilerHelperKind::HelperDependency => None,
}
}
fn collect_default_object_helper_exports(module: &Module) -> Vec<HelperExportFact> {
let local_helpers = collect_transpiler_helpers(module);
let local_kinds: std::collections::HashMap<Atom, HelperKind> = local_helpers
.iter()
.filter_map(|((local, _), kind)| {
helper_kind_from_transpiler(*kind).map(|kind| (local.clone(), kind))
})
.collect();
let mut helper_exports = Vec::new();
for prop in default_export_object_props(module) {
let Some((exported, local)) = object_prop_exported_local(prop) else {
continue;
};
let Some(kind) = local_kinds.get(&local).copied() else {
continue;
};
helper_exports.push(HelperExportFact {
exported,
local: Some(local),
kind,
});
}
helper_exports
}
fn default_export_object_props(module: &Module) -> impl Iterator<Item = &Prop> {
module
.body
.iter()
.filter_map(|item| {
let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export)) = item else {
return None;
};
let Expr::Object(object) = export.expr.as_ref() else {
return None;
};
Some(object.props.iter().filter_map(|prop| match prop {
swc_core::ecma::ast::PropOrSpread::Prop(prop) => Some(prop.as_ref()),
swc_core::ecma::ast::PropOrSpread::Spread(_) => None,
}))
})
.flatten()
}
fn object_prop_exported_local(prop: &Prop) -> Option<(Atom, Atom)> {
match prop {
Prop::Shorthand(id) => Some((id.sym.clone(), id.sym.clone())),
Prop::KeyValue(kv) => {
let exported = prop_name_to_atom(&kv.key)?;
let Expr::Ident(local) = kv.value.as_ref() else {
return None;
};
Some((exported, local.sym.clone()))
}
_ => None,
}
}
fn prop_name_to_atom(name: &PropName) -> Option<Atom> {
match name {
PropName::Ident(id) => Some(id.sym.clone()),
PropName::Str(s) => Some(str_to_atom(&s.value)),
PropName::Num(num) => Some(Atom::from(num.value.to_string())),
_ => None,
}
}
fn helper_kind_from_ts(kind: TsHelperKind) -> TypeScriptHelperKind {
match kind {
TsHelperKind::Awaiter => TypeScriptHelperKind::Awaiter,
TsHelperKind::Generator => TypeScriptHelperKind::Generator,
TsHelperKind::Values => TypeScriptHelperKind::Values,
TsHelperKind::Assign => TypeScriptHelperKind::Assign,
TsHelperKind::Rest => TypeScriptHelperKind::Rest,
TsHelperKind::Extends => TypeScriptHelperKind::Extends,
TsHelperKind::ImportDefault => TypeScriptHelperKind::ImportDefault,
TsHelperKind::ImportStar => TypeScriptHelperKind::ImportStar,
TsHelperKind::CreateBinding => TypeScriptHelperKind::CreateBinding,
TsHelperKind::SetModuleDefault => TypeScriptHelperKind::SetModuleDefault,
TsHelperKind::Read => TypeScriptHelperKind::Read,
TsHelperKind::Spread => TypeScriptHelperKind::Spread,
TsHelperKind::SpreadArrays => TypeScriptHelperKind::SpreadArrays,
TsHelperKind::SpreadArray => TypeScriptHelperKind::SpreadArray,
TsHelperKind::ClassPrivateFieldGet => TypeScriptHelperKind::ClassPrivateFieldGet,
TsHelperKind::ClassPrivateFieldSet => TypeScriptHelperKind::ClassPrivateFieldSet,
}
}
fn ts_helper_kind_from_name(name: &str) -> Option<TypeScriptHelperKind> {
match name {
"__awaiter" => Some(TypeScriptHelperKind::Awaiter),
"__generator" => Some(TypeScriptHelperKind::Generator),
"__values" | "_ts_values" => Some(TypeScriptHelperKind::Values),
"__assign" => Some(TypeScriptHelperKind::Assign),
"__rest" => Some(TypeScriptHelperKind::Rest),
"__extends" => Some(TypeScriptHelperKind::Extends),
"__importDefault" => Some(TypeScriptHelperKind::ImportDefault),
"__importStar" => Some(TypeScriptHelperKind::ImportStar),
"__createBinding" => Some(TypeScriptHelperKind::CreateBinding),
"__setModuleDefault" => Some(TypeScriptHelperKind::SetModuleDefault),
"__spreadArray" => Some(TypeScriptHelperKind::SpreadArray),
"__classPrivateFieldGet" => Some(TypeScriptHelperKind::ClassPrivateFieldGet),
"__classPrivateFieldSet" => Some(TypeScriptHelperKind::ClassPrivateFieldSet),
_ => None,
}
}
fn is_regenerator_runtime_binding(module: &Module, local: &Atom) -> bool {
struct Finder<'a> {
local: &'a Atom,
found: bool,
}
impl Visit for Finder<'_> {
fn visit_function(&mut self, _: &swc_core::ecma::ast::Function) {}
fn visit_arrow_expr(&mut self, _: &swc_core::ecma::ast::ArrowExpr) {}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
let Some(right) = assign.right.as_ident() else {
assign.visit_children_with(self);
return;
};
if right.sym != *self.local {
assign.visit_children_with(self);
return;
}
let Some(left) = assign.left.as_simple() else {
assign.visit_children_with(self);
return;
};
if matches!(
left.as_ident(),
Some(ident) if ident.sym.as_ref() == "regeneratorRuntime"
) {
self.found = true;
return;
}
if let Some(member) = left.as_member() {
if is_member_prop_name(&member.prop, "regeneratorRuntime") {
self.found = true;
return;
}
}
assign.visit_children_with(self);
}
}
let mut finder = Finder {
local,
found: false,
};
module.visit_with(&mut finder);
finder.found
}
/// Detect `export default require("./X.js")` — a pure passthrough module that
/// re-exports another module's namespace as its default export. Returns the
/// target specifier.
///
/// Only matches modules whose body contains nothing except the single
/// `export default require("./X.js")`. Any other statement (side effects,
/// imports, additional exports) disqualifies the module.
fn detect_passthrough(module: &Module) -> Option<Atom> {
if module.body.len() != 1 {
return None;
}
let ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(export)) = &module.body[0] else {
return None;
};
let Expr::Call(call) = export.expr.as_ref() else {
return None;
};
let Callee::Expr(callee) = &call.callee else {
return None;
};
let Expr::Ident(ident) = callee.as_ref() else {
return None;
};
if ident.sym != "require" || call.args.len() != 1 || call.args[0].spread.is_some() {
return None;
}
let Expr::Lit(Lit::Str(s)) = call.args[0].expr.as_ref() else {
return None;
};
Some(str_to_atom(&s.value))
}
fn export_name_to_atom(name: &swc_core::ecma::ast::ModuleExportName) -> Atom {
match name {
swc_core::ecma::ast::ModuleExportName::Ident(id) => id.sym.clone(),
swc_core::ecma::ast::ModuleExportName::Str(s) => str_to_atom(&s.value),
}
}
fn str_to_atom(value: &swc_core::atoms::Wtf8Atom) -> Atom {
Atom::from(value.as_str().unwrap_or(""))
}
fn is_member_prop_name(prop: &swc_core::ecma::ast::MemberProp, name: &str) -> bool {
match prop {
swc_core::ecma::ast::MemberProp::Ident(id) => id.sym.as_ref() == name,
swc_core::ecma::ast::MemberProp::Computed(computed) => {
matches!(
computed.expr.as_ref(),
Expr::Lit(Lit::Str(s)) if s.value.as_str() == Some(name)
)
}
swc_core::ecma::ast::MemberProp::PrivateName(_) => false,
}
}