crates/core/src/reexport_consolidation.rs
GitHub//! Re-export consolidation: redirect imports from passthrough modules to the
//! actual target module.
//!
//! A passthrough module has the shape `export default require("./X.js")` with
//! no other statements — it re-exports another module's namespace as its
//! default export. When the imported binding is only used via member access
//! (e.g. `x.foo`, `x.bar`), the import is rewritten:
//! `import x from "./passthrough.js"` → `import * as x from "./target.js"`
//!
//! The resulting namespace imports can then be further decomposed into named
//! imports by the namespace decomposition pass.
use swc_core::atoms::Atom;
use swc_core::common::{SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
AssignExpr, AssignTarget, Expr, Ident, ImportDecl, ImportSpecifier, ImportStarAsSpecifier,
MemberExpr, MemberProp, Module, ModuleDecl, ModuleItem, SimpleAssignTarget, Str, UnaryExpr,
UnaryOp, UpdateExpr,
};
use swc_core::ecma::visit::{Visit, VisitWith};
use crate::facts::ModuleFactsMap;
use crate::module_path::relative_import_specifier;
pub fn run_reexport_consolidation(
module: &mut Module,
module_facts: &ModuleFactsMap,
current_filename: Option<&str>,
) {
if module_facts.is_empty() {
return;
}
let redirects: Vec<(usize, Atom)> = module
.body
.iter()
.enumerate()
.filter_map(|(idx, item)| {
let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
return None;
};
if import.specifiers.len() != 1 {
return None;
}
let ImportSpecifier::Default(default_spec) = &import.specifiers[0] else {
return None;
};
let source_str = import.src.value.as_str().unwrap_or("");
let target = resolve_passthrough(source_str, module_facts, current_filename)?;
let mut analyzer = MemberOnlyAnalyzer {
target_sym: &default_spec.local.sym,
target_ctxt: default_spec.local.ctxt,
safe: true,
in_import_decl: false,
};
module.visit_with(&mut analyzer);
if !analyzer.safe {
return None;
}
Some((idx, target))
})
.collect();
for (idx, target) in redirects {
let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = &mut module.body[idx] else {
continue;
};
let ImportSpecifier::Default(default_spec) = &import.specifiers[0] else {
continue;
};
let local_ident = default_spec.local.clone();
import.specifiers = vec![ImportSpecifier::Namespace(ImportStarAsSpecifier {
span: DUMMY_SP,
local: Ident::new(local_ident.sym, DUMMY_SP, local_ident.ctxt),
})];
*import.src = Str::from(target.as_ref());
}
}
fn resolve_passthrough(
source: &str,
facts: &ModuleFactsMap,
current_filename: Option<&str>,
) -> Option<Atom> {
let original_importer = current_filename?;
let mut current = facts.resolve_key_from(current_filename, source)?;
let mut seen = std::collections::HashSet::new();
loop {
if !seen.insert(current.clone()) {
return None;
}
let module_facts = facts.get(¤t)?;
let target = module_facts.passthrough_target.as_ref()?;
let target_str = target.as_ref();
if let Some(target_key) = facts.resolve_key_from(Some(¤t), target_str) {
let target_facts = facts.get(&target_key)?;
if target_facts.passthrough_target.is_some() {
current = target_key;
continue;
}
return Some(Atom::from(relative_import_specifier(
original_importer,
&target_key,
)));
}
return Some(target.clone());
}
}
struct MemberOnlyAnalyzer<'a> {
target_sym: &'a Atom,
target_ctxt: SyntaxContext,
safe: bool,
in_import_decl: bool,
}
impl MemberOnlyAnalyzer<'_> {
fn is_target(&self, ident: &Ident) -> bool {
ident.sym == *self.target_sym && ident.ctxt == self.target_ctxt
}
}
impl Visit for MemberOnlyAnalyzer<'_> {
fn visit_import_decl(&mut self, import: &ImportDecl) {
self.in_import_decl = true;
import.visit_children_with(self);
self.in_import_decl = false;
}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left {
if matches!(member.obj.as_ref(), Expr::Ident(obj) if self.is_target(obj)) {
self.safe = false;
assign.right.visit_with(self);
return;
}
}
assign.visit_children_with(self);
}
fn visit_update_expr(&mut self, update: &UpdateExpr) {
if let Expr::Member(member) = update.arg.as_ref() {
if matches!(member.obj.as_ref(), Expr::Ident(obj) if self.is_target(obj)) {
self.safe = false;
return;
}
}
update.visit_children_with(self);
}
fn visit_unary_expr(&mut self, unary: &UnaryExpr) {
if unary.op == UnaryOp::Delete {
if let Expr::Member(member) = unary.arg.as_ref() {
if matches!(member.obj.as_ref(), Expr::Ident(obj) if self.is_target(obj)) {
self.safe = false;
return;
}
}
}
unary.visit_children_with(self);
}
fn visit_member_expr(&mut self, member: &MemberExpr) {
if let Expr::Ident(obj) = member.obj.as_ref() {
if self.is_target(obj) {
match &member.prop {
MemberProp::Ident(_) => return,
MemberProp::Computed(_) => {
self.safe = false;
return;
}
_ => {
self.safe = false;
return;
}
}
}
}
member.visit_children_with(self);
}
fn visit_ident(&mut self, ident: &Ident) {
if self.in_import_decl {
return;
}
if self.is_target(ident) {
self.safe = false;
}
}
fn visit_prop_name(&mut self, _: &swc_core::ecma::ast::PropName) {}
fn visit_member_prop(&mut self, prop: &MemberProp) {
if let MemberProp::Computed(prop) = prop {
prop.visit_with(self);
}
}
}