crates/core/src/vue_recovery/imports.rs
GitHubuse std::collections::{HashMap, HashSet};
use swc_core::atoms::Atom;
use swc_core::common::{sync::Lrc, SourceMap};
use swc_core::ecma::ast::{
ArrowExpr, AssignExpr, AssignTarget, BlockStmt, BlockStmtOrExpr, Callee, Decl, DefaultDecl,
ExportSpecifier, Expr, Function, Lit, MemberProp, Module, ModuleDecl, ModuleItem, ObjectLit,
Pat, Prop, PropOrSpread, ReturnStmt, SimpleAssignTarget, Stmt, UnaryOp, UpdateExpr,
VarDeclarator,
};
use swc_core::ecma::visit::{Visit, VisitWith};
use super::context::{call_callee_ident, unwrap_paren_expr};
use super::parse_module;
use super::syntax::{module_export_name, prop_name, string_lit};
pub(super) fn composable_ref_props_from_source(source: &str) -> HashMap<String, HashSet<Atom>> {
let cm: Lrc<SourceMap> = Default::default();
if let Ok(module) = parse_module(source, cm) {
let exports = composable_ref_props_from_module(&module);
if !exports.is_empty() {
return exports;
}
}
let Some(result) = crate::unpacker::unpack_bundle(source) else {
return HashMap::new();
};
if result.modules.len() != 1 {
return HashMap::new();
}
let Some(module) = result.modules.into_iter().next() else {
return HashMap::new();
};
let cm: Lrc<SourceMap> = Default::default();
parse_module(&module.code, cm)
.map(|module| composable_ref_props_from_module(&module))
.unwrap_or_default()
}
fn composable_ref_props_from_module(module: &Module) -> HashMap<String, HashSet<Atom>> {
let (mut local_ref_props, ref_returning_functions) = local_composable_ref_prop_analysis(module);
local_ref_props.extend(local_injected_composable_ref_props(
module,
&local_ref_props,
));
composable_ref_prop_exports(module, &local_ref_props, &ref_returning_functions)
}
pub(super) fn local_composable_ref_props_from_module(
module: &Module,
) -> HashMap<Atom, HashSet<Atom>> {
local_composable_ref_prop_analysis(module).0
}
fn local_composable_ref_prop_analysis(
module: &Module,
) -> (HashMap<Atom, HashSet<Atom>>, HashSet<Atom>) {
let local_functions = local_function_likes(module);
let ref_returning_functions = ref_returning_function_bindings(&local_functions);
let local_ref_props = local_functions
.iter()
.filter_map(|(binding, function)| {
composable_ref_props_from_function(*function, &ref_returning_functions)
.map(|props| (binding.clone(), props))
})
.collect::<HashMap<_, _>>();
(local_ref_props, ref_returning_functions)
}
fn local_injected_composable_ref_props(
module: &Module,
local_ref_props: &HashMap<Atom, HashSet<Atom>>,
) -> HashMap<Atom, HashSet<Atom>> {
let mut values = local_ref_props.values();
let Some(provider_ref_props) = values.next() else {
return HashMap::new();
};
if values.next().is_some() {
return HashMap::new();
}
local_function_likes(module)
.into_iter()
.filter(|(binding, _)| !local_ref_props.contains_key(binding))
.filter_map(|(binding, function)| {
function_returns_guarded_call_result(function)
.then(|| (binding, provider_ref_props.clone()))
})
.collect()
}
fn function_returns_guarded_call_result(function: FunctionLike<'_>) -> bool {
if !function_has_no_params(function) {
return false;
}
let return_exprs = function_return_exprs(function);
let [return_expr] = return_exprs.as_slice() else {
return false;
};
let Expr::Ident(returned) = unwrap_paren_expr(return_expr) else {
return false;
};
let Some(stmts) = function_block_stmts(function) else {
return false;
};
block_declares_call_result(stmts, &returned.sym)
&& block_guards_missing_result(stmts, &returned.sym)
}
fn function_has_no_params(function: FunctionLike<'_>) -> bool {
match function {
FunctionLike::Function(function) => function.params.is_empty(),
FunctionLike::Arrow(arrow) => arrow.params.is_empty(),
}
}
fn function_block_stmts(function: FunctionLike<'_>) -> Option<&[Stmt]> {
match function {
FunctionLike::Function(function) => {
function.body.as_ref().map(|body| body.stmts.as_slice())
}
FunctionLike::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => Some(block.stmts.as_slice()),
BlockStmtOrExpr::Expr(_) => None,
},
}
}
fn block_declares_call_result(stmts: &[Stmt], binding: &Atom) -> bool {
stmts.iter().any(|stmt| {
let Stmt::Decl(Decl::Var(var)) = stmt else {
return false;
};
var.decls.iter().any(|decl| {
let Pat::Ident(ident) = &decl.name else {
return false;
};
&ident.id.sym == binding
&& decl
.init
.as_deref()
.is_some_and(|init| matches!(unwrap_paren_expr(init), Expr::Call(_)))
})
})
}
fn block_guards_missing_result(stmts: &[Stmt], binding: &Atom) -> bool {
stmts.iter().any(|stmt| match stmt {
Stmt::If(if_stmt) if is_missing_binding_test(if_stmt.test.as_ref(), binding) => {
stmt_contains_throw(if_stmt.cons.as_ref())
|| if_stmt.alt.as_deref().is_some_and(stmt_contains_throw)
}
_ => false,
})
}
fn is_missing_binding_test(expr: &Expr, binding: &Atom) -> bool {
matches!(
unwrap_paren_expr(expr),
Expr::Unary(unary)
if unary.op == UnaryOp::Bang
&& matches!(unwrap_paren_expr(unary.arg.as_ref()), Expr::Ident(ident) if &ident.sym == binding)
)
}
fn stmt_contains_throw(stmt: &Stmt) -> bool {
match stmt {
Stmt::Throw(_) => true,
Stmt::Block(block) => block.stmts.iter().any(stmt_contains_throw),
Stmt::If(if_stmt) => {
stmt_contains_throw(if_stmt.cons.as_ref())
|| if_stmt.alt.as_deref().is_some_and(stmt_contains_throw)
}
_ => false,
}
}
#[derive(Clone, Copy)]
enum FunctionLike<'a> {
Function(&'a Function),
Arrow(&'a ArrowExpr),
}
fn local_function_likes(module: &Module) -> Vec<(Atom, FunctionLike<'_>)> {
let mut functions = Vec::new();
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Decl(decl)) => {
collect_decl_function_likes(decl, &mut functions);
}
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {
collect_decl_function_likes(&export.decl, &mut functions);
}
_ => {}
}
}
functions
}
fn collect_decl_function_likes<'a>(decl: &'a Decl, functions: &mut Vec<(Atom, FunctionLike<'a>)>) {
match decl {
Decl::Fn(function) => {
functions.push((
function.ident.sym.clone(),
FunctionLike::Function(&function.function),
));
}
Decl::Var(var) => {
for declarator in &var.decls {
let Pat::Ident(binding) = &declarator.name else {
continue;
};
let Some(init) = declarator.init.as_deref() else {
continue;
};
match unwrap_paren_expr(init) {
Expr::Arrow(arrow) => {
functions.push((binding.id.sym.clone(), FunctionLike::Arrow(arrow)));
}
Expr::Fn(function) => {
functions.push((
binding.id.sym.clone(),
FunctionLike::Function(&function.function),
));
}
_ => {}
}
}
}
_ => {}
}
}
fn ref_returning_function_bindings(functions: &[(Atom, FunctionLike<'_>)]) -> HashSet<Atom> {
let mut ref_returning = HashSet::new();
loop {
let mut changed = false;
for (binding, function) in functions {
if ref_returning.contains(binding) {
continue;
}
if function_returns_ref_like(*function, &ref_returning) {
changed |= ref_returning.insert(binding.clone());
}
}
if !changed {
return ref_returning;
}
}
}
fn function_returns_ref_like(
function: FunctionLike<'_>,
ref_returning_functions: &HashSet<Atom>,
) -> bool {
let value_writes = function_value_write_bindings(function);
if value_writes.is_empty() && ref_returning_functions.is_empty() {
return false;
}
function_return_exprs(function)
.into_iter()
.any(|expr| expr_returns_ref_like(&expr, &value_writes, ref_returning_functions))
}
fn function_value_write_bindings(function: FunctionLike<'_>) -> HashSet<Atom> {
let mut collector = ValueWriteCollector {
bindings: HashSet::new(),
};
match function {
FunctionLike::Function(function) => {
if let Some(body) = &function.body {
body.visit_with(&mut collector);
}
}
FunctionLike::Arrow(arrow) => {
arrow.body.visit_with(&mut collector);
}
}
collector.bindings
}
struct ValueWriteCollector {
bindings: HashSet<Atom>,
}
impl Visit for ValueWriteCollector {
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &assign.left {
if member_prop_is_value(&member.prop) {
if let Expr::Ident(object) = unwrap_paren_expr(member.obj.as_ref()) {
self.bindings.insert(object.sym.clone());
}
}
}
assign.right.visit_with(self);
}
fn visit_update_expr(&mut self, update: &UpdateExpr) {
if let Expr::Member(member) = unwrap_paren_expr(update.arg.as_ref()) {
if member_prop_is_value(&member.prop) {
if let Expr::Ident(object) = unwrap_paren_expr(member.obj.as_ref()) {
self.bindings.insert(object.sym.clone());
}
}
}
}
}
fn function_return_exprs(function: FunctionLike<'_>) -> Vec<Expr> {
match function {
FunctionLike::Function(function) => function
.body
.as_ref()
.map(|body| block_return_exprs(body.stmts.as_slice()))
.unwrap_or_default(),
FunctionLike::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => block_return_exprs(block.stmts.as_slice()),
BlockStmtOrExpr::Expr(expr) => vec![expr.as_ref().clone()],
},
}
}
fn block_return_exprs(stmts: &[Stmt]) -> Vec<Expr> {
let mut collector = ReturnExprCollector { exprs: Vec::new() };
for stmt in stmts {
stmt.visit_with(&mut collector);
}
collector.exprs
}
struct ReturnExprCollector {
exprs: Vec<Expr>,
}
impl Visit for ReturnExprCollector {
fn visit_return_stmt(&mut self, stmt: &ReturnStmt) {
if let Some(expr) = &stmt.arg {
self.exprs.push(expr.as_ref().clone());
}
}
fn visit_function(&mut self, _function: &Function) {}
fn visit_arrow_expr(&mut self, _arrow: &ArrowExpr) {}
}
fn expr_returns_ref_like(
expr: &Expr,
value_writes: &HashSet<Atom>,
ref_returning_functions: &HashSet<Atom>,
) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => value_writes.contains(&ident.sym),
Expr::Seq(seq) => seq
.exprs
.last()
.is_some_and(|expr| expr_returns_ref_like(expr, value_writes, ref_returning_functions)),
Expr::Call(call) => {
call_callee_ident(call)
.is_some_and(|callee| ref_returning_functions.contains(&callee.sym))
|| call.args.iter().any(|arg| {
matches!(
unwrap_paren_expr(arg.expr.as_ref()),
Expr::Ident(ident) if value_writes.contains(&ident.sym)
)
})
}
Expr::Cond(cond) => {
expr_returns_ref_like(cond.cons.as_ref(), value_writes, ref_returning_functions)
&& expr_returns_ref_like(cond.alt.as_ref(), value_writes, ref_returning_functions)
}
_ => false,
}
}
fn composable_ref_props_from_function(
function: FunctionLike<'_>,
ref_returning_functions: &HashSet<Atom>,
) -> Option<HashSet<Atom>> {
let local_ref_bindings = composable_local_ref_bindings(function, ref_returning_functions);
if local_ref_bindings.is_empty() && ref_returning_functions.is_empty() {
return None;
}
let mut ref_props = HashSet::new();
for expr in function_return_exprs(function) {
let Some(object) = returned_object_expr(&expr) else {
continue;
};
ref_props.extend(object_ref_props(
&object,
&local_ref_bindings,
ref_returning_functions,
));
}
(!ref_props.is_empty()).then_some(ref_props)
}
pub(super) fn composable_ref_props_from_iife_call(expr: &Expr) -> Option<HashSet<Atom>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return None;
};
let Callee::Expr(callee) = &call.callee else {
return None;
};
match unwrap_paren_expr(callee.as_ref()) {
Expr::Arrow(arrow) => {
composable_ref_props_from_function(FunctionLike::Arrow(arrow), &HashSet::new())
}
Expr::Fn(function) => composable_ref_props_from_function(
FunctionLike::Function(&function.function),
&HashSet::new(),
),
_ => None,
}
}
fn composable_local_ref_bindings(
function: FunctionLike<'_>,
ref_returning_functions: &HashSet<Atom>,
) -> HashSet<Atom> {
let value_member_refs = function_value_member_bindings(function);
let strong_value_member_refs = function_strong_value_member_bindings(function);
let called_bindings = function_called_bindings(function);
let tuple_ref_bindings =
function_tuple_ref_bindings(function, &value_member_refs, &called_bindings);
let mut collector = RefLocalCollector {
refs: tuple_ref_bindings,
strong_value_member_refs: &strong_value_member_refs,
ref_returning_functions,
};
match function {
FunctionLike::Function(function) => {
if let Some(body) = &function.body {
body.visit_with(&mut collector);
}
}
FunctionLike::Arrow(arrow) => {
arrow.body.visit_with(&mut collector);
}
}
collector.refs
}
fn function_value_member_bindings(function: FunctionLike<'_>) -> HashSet<Atom> {
let mut collector = ValueMemberCollector {
bindings: HashSet::new(),
};
match function {
FunctionLike::Function(function) => {
if let Some(body) = &function.body {
body.visit_with(&mut collector);
}
}
FunctionLike::Arrow(arrow) => {
arrow.body.visit_with(&mut collector);
}
}
collector.bindings
}
fn function_strong_value_member_bindings(function: FunctionLike<'_>) -> HashSet<Atom> {
let mut collector = StrongValueMemberCollector {
bindings: HashSet::new(),
shadowed: Vec::new(),
};
match function {
FunctionLike::Function(function) => {
if let Some(body) = &function.body {
for stmt in &body.stmts {
stmt.visit_with(&mut collector);
}
}
}
FunctionLike::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => {
for stmt in &block.stmts {
stmt.visit_with(&mut collector);
}
}
BlockStmtOrExpr::Expr(expr) => {
expr.visit_with(&mut collector);
}
},
}
collector.bindings
}
struct StrongValueMemberCollector {
bindings: HashSet<Atom>,
shadowed: Vec<HashSet<Atom>>,
}
impl StrongValueMemberCollector {
fn collect_value_member_expr(&mut self, expr: &Expr) {
if let Some(binding) = value_member_object(expr) {
if !self.is_shadowed(&binding) {
self.bindings.insert(binding);
}
}
}
fn is_shadowed(&self, binding: &Atom) -> bool {
self.shadowed
.iter()
.rev()
.any(|scope| scope.contains(binding))
}
fn enter_shadowed(&mut self, bindings: HashSet<Atom>) -> bool {
if bindings.is_empty() {
return false;
}
self.shadowed.push(bindings);
true
}
fn exit_shadowed(&mut self, entered: bool) {
if entered {
self.shadowed.pop();
}
}
}
impl Visit for StrongValueMemberCollector {
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
match &assign.left {
AssignTarget::Simple(SimpleAssignTarget::Member(member)) => {
self.collect_value_member_expr(&Expr::Member(member.clone()));
}
AssignTarget::Simple(_) | AssignTarget::Pat(_) => {}
}
assign.right.visit_with(self);
}
fn visit_update_expr(&mut self, update: &UpdateExpr) {
self.collect_value_member_expr(update.arg.as_ref());
}
fn visit_call_expr(&mut self, call: &swc_core::ecma::ast::CallExpr) {
if let Callee::Expr(callee) = &call.callee {
if let Expr::Member(member) = unwrap_paren_expr(callee.as_ref()) {
self.collect_value_member_expr(member.obj.as_ref());
} else {
callee.visit_with(self);
}
}
for arg in &call.args {
self.collect_value_member_expr(arg.expr.as_ref());
arg.expr.visit_with(self);
}
}
fn visit_block_stmt(&mut self, block: &BlockStmt) {
let shadowed = block_shadowed_bindings(block);
let entered = self.enter_shadowed(shadowed);
block.visit_children_with(self);
self.exit_shadowed(entered);
}
fn visit_function(&mut self, function: &Function) {
let shadowed = function
.params
.iter()
.flat_map(|param| pat_bound_atoms(¶m.pat))
.collect::<HashSet<_>>();
let entered = self.enter_shadowed(shadowed);
if let Some(body) = &function.body {
body.visit_with(self);
}
self.exit_shadowed(entered);
}
fn visit_arrow_expr(&mut self, arrow: &ArrowExpr) {
let shadowed = arrow
.params
.iter()
.flat_map(pat_bound_atoms)
.collect::<HashSet<_>>();
let entered = self.enter_shadowed(shadowed);
arrow.body.visit_with(self);
self.exit_shadowed(entered);
}
}
fn block_shadowed_bindings(block: &BlockStmt) -> HashSet<Atom> {
let mut bindings = HashSet::new();
for stmt in &block.stmts {
if let Stmt::Decl(decl) = stmt {
collect_decl_bound_atoms(decl, &mut bindings);
}
}
bindings
}
fn collect_decl_bound_atoms(decl: &Decl, bindings: &mut HashSet<Atom>) {
match decl {
Decl::Class(class) => {
bindings.insert(class.ident.sym.clone());
}
Decl::Fn(function) => {
bindings.insert(function.ident.sym.clone());
}
Decl::Var(var) => {
for declarator in &var.decls {
collect_pat_bound_atoms(&declarator.name, bindings);
}
}
_ => {}
}
}
fn pat_bound_atoms(pat: &Pat) -> HashSet<Atom> {
let mut bindings = HashSet::new();
collect_pat_bound_atoms(pat, &mut bindings);
bindings
}
fn collect_pat_bound_atoms(pat: &Pat, bindings: &mut HashSet<Atom>) {
match pat {
Pat::Ident(binding) => {
bindings.insert(binding.id.sym.clone());
}
Pat::Array(array) => {
for elem in array.elems.iter().flatten() {
collect_pat_bound_atoms(elem, bindings);
}
}
Pat::Rest(rest) => {
collect_pat_bound_atoms(rest.arg.as_ref(), bindings);
}
Pat::Object(object) => {
for prop in &object.props {
match prop {
swc_core::ecma::ast::ObjectPatProp::KeyValue(key_value) => {
collect_pat_bound_atoms(key_value.value.as_ref(), bindings);
}
swc_core::ecma::ast::ObjectPatProp::Assign(assign) => {
bindings.insert(assign.key.sym.clone());
}
swc_core::ecma::ast::ObjectPatProp::Rest(rest) => {
collect_pat_bound_atoms(rest.arg.as_ref(), bindings);
}
}
}
}
Pat::Assign(assign) => {
collect_pat_bound_atoms(assign.left.as_ref(), bindings);
}
Pat::Expr(_) | Pat::Invalid(_) => {}
}
}
struct ValueMemberCollector {
bindings: HashSet<Atom>,
}
impl Visit for ValueMemberCollector {
fn visit_member_prop(&mut self, prop: &MemberProp) {
if let MemberProp::Computed(computed) = prop {
computed.visit_with(self);
}
}
fn visit_member_expr(&mut self, member: &swc_core::ecma::ast::MemberExpr) {
if member_prop_is_value(&member.prop) {
if let Expr::Ident(object) = unwrap_paren_expr(member.obj.as_ref()) {
self.bindings.insert(object.sym.clone());
}
}
member.obj.visit_with(self);
if let MemberProp::Computed(computed) = &member.prop {
computed.visit_with(self);
}
}
}
fn function_called_bindings(function: FunctionLike<'_>) -> HashSet<Atom> {
let mut collector = CalledBindingCollector {
bindings: HashSet::new(),
};
match function {
FunctionLike::Function(function) => {
if let Some(body) = &function.body {
body.visit_with(&mut collector);
}
}
FunctionLike::Arrow(arrow) => {
arrow.body.visit_with(&mut collector);
}
}
collector.bindings
}
struct CalledBindingCollector {
bindings: HashSet<Atom>,
}
impl Visit for CalledBindingCollector {
fn visit_call_expr(&mut self, call: &swc_core::ecma::ast::CallExpr) {
if let Callee::Expr(callee) = &call.callee {
if let Expr::Ident(ident) = unwrap_paren_expr(callee.as_ref()) {
self.bindings.insert(ident.sym.clone());
}
}
call.visit_children_with(self);
}
}
fn function_tuple_ref_bindings(
function: FunctionLike<'_>,
value_member_refs: &HashSet<Atom>,
called_bindings: &HashSet<Atom>,
) -> HashSet<Atom> {
let mut collector = TupleRefBindingCollector {
value_member_refs,
called_bindings,
refs: HashSet::new(),
tuple_member_aliases: Vec::new(),
};
match function {
FunctionLike::Function(function) => {
if let Some(body) = &function.body {
body.visit_with(&mut collector);
}
}
FunctionLike::Arrow(arrow) => {
arrow.body.visit_with(&mut collector);
}
}
collector.finish()
}
struct TupleMemberAlias {
tuple: Atom,
index: usize,
binding: Atom,
}
struct TupleRefBindingCollector<'a> {
value_member_refs: &'a HashSet<Atom>,
called_bindings: &'a HashSet<Atom>,
refs: HashSet<Atom>,
tuple_member_aliases: Vec<TupleMemberAlias>,
}
impl TupleRefBindingCollector<'_> {
fn collect_array_pat(&mut self, pat: &swc_core::ecma::ast::ArrayPat) {
let has_called_sibling = pat.elems.iter().enumerate().any(|(index, elem)| {
index > 0 && elem.as_ref().is_some_and(|elem| self.pat_is_called(elem))
});
if !has_called_sibling {
return;
}
let Some(Some(Pat::Ident(binding))) = pat.elems.first() else {
return;
};
if self.value_member_refs.contains(&binding.id.sym) {
self.refs.insert(binding.id.sym.clone());
}
}
fn pat_is_called(&self, pat: &Pat) -> bool {
match pat {
Pat::Ident(binding) => self.called_bindings.contains(&binding.id.sym),
Pat::Assign(assign) => self.pat_is_called(assign.left.as_ref()),
_ => false,
}
}
fn finish(mut self) -> HashSet<Atom> {
let called_tuple_sources = self
.tuple_member_aliases
.iter()
.filter(|alias| alias.index > 0 && self.called_bindings.contains(&alias.binding))
.map(|alias| alias.tuple.clone())
.collect::<HashSet<_>>();
self.refs.extend(
self.tuple_member_aliases
.into_iter()
.filter(|alias| {
alias.index == 0
&& self.value_member_refs.contains(&alias.binding)
&& called_tuple_sources.contains(&alias.tuple)
})
.map(|alias| alias.binding),
);
self.refs
}
}
impl Visit for TupleRefBindingCollector<'_> {
fn visit_var_declarator(&mut self, declarator: &VarDeclarator) {
match (&declarator.name, declarator.init.as_deref()) {
(Pat::Array(array), Some(_)) => self.collect_array_pat(array),
(Pat::Ident(binding), Some(init)) => {
if let Some((tuple, index)) = tuple_member_index(init) {
self.tuple_member_aliases.push(TupleMemberAlias {
tuple,
index,
binding: binding.id.sym.clone(),
});
}
}
_ => {}
}
}
fn visit_function(&mut self, _function: &Function) {}
fn visit_arrow_expr(&mut self, _arrow: &ArrowExpr) {}
}
struct RefLocalCollector<'a> {
refs: HashSet<Atom>,
strong_value_member_refs: &'a HashSet<Atom>,
ref_returning_functions: &'a HashSet<Atom>,
}
impl Visit for RefLocalCollector<'_> {
fn visit_var_declarator(&mut self, declarator: &VarDeclarator) {
let Some(init) = declarator.init.as_deref() else {
return;
};
match &declarator.name {
Pat::Ident(binding)
if expr_is_ref_binding_init(init, &self.refs, self.ref_returning_functions)
|| (is_ref_candidate_init(init)
&& self.strong_value_member_refs.contains(&binding.id.sym)) =>
{
self.refs.insert(binding.id.sym.clone());
}
Pat::Object(object) if is_ref_candidate_init(init) => {
collect_object_pat_ref_bindings(
object,
self.strong_value_member_refs,
&mut self.refs,
);
}
_ => {}
}
}
fn visit_function(&mut self, _function: &Function) {}
fn visit_arrow_expr(&mut self, _arrow: &ArrowExpr) {}
}
fn is_ref_candidate_init(expr: &Expr) -> bool {
matches!(unwrap_paren_expr(expr), Expr::Call(_))
}
fn expr_is_ref_binding_init(
expr: &Expr,
local_ref_bindings: &HashSet<Atom>,
ref_returning_functions: &HashSet<Atom>,
) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => local_ref_bindings.contains(&ident.sym),
Expr::Seq(seq) => seq.exprs.last().is_some_and(|expr| {
expr_is_ref_binding_init(expr, local_ref_bindings, ref_returning_functions)
}),
Expr::Call(call) => call_callee_ident(call)
.is_some_and(|callee| ref_returning_functions.contains(&callee.sym)),
_ => false,
}
}
fn returned_object_expr(expr: &Expr) -> Option<ObjectLit> {
match unwrap_paren_expr(expr) {
Expr::Object(object) => Some(object.clone()),
Expr::Seq(seq) => seq.exprs.last().and_then(|expr| returned_object_expr(expr)),
_ => None,
}
}
fn object_ref_props(
object: &ObjectLit,
local_ref_bindings: &HashSet<Atom>,
ref_returning_functions: &HashSet<Atom>,
) -> HashSet<Atom> {
let mut ref_props = HashSet::new();
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
continue;
};
match prop.as_ref() {
Prop::Shorthand(ident) if local_ref_bindings.contains(&ident.sym) => {
ref_props.insert(ident.sym.clone());
}
Prop::KeyValue(key_value) => {
let value = unwrap_paren_expr(key_value.value.as_ref());
let is_ref_value = match value {
Expr::Ident(value) => local_ref_bindings.contains(&value.sym),
Expr::Call(call) => call_callee_ident(call)
.is_some_and(|callee| ref_returning_functions.contains(&callee.sym)),
_ => false,
};
if !is_ref_value {
continue;
}
if let Some(name) = prop_name(&key_value.key) {
ref_props.insert(Atom::from(name));
}
}
_ => {}
}
}
ref_props
}
fn value_member_object(expr: &Expr) -> Option<Atom> {
match unwrap_paren_expr(expr) {
Expr::Member(member) if member_prop_is_value(&member.prop) => {
match unwrap_paren_expr(member.obj.as_ref()) {
Expr::Ident(object) => Some(object.sym.clone()),
_ => None,
}
}
Expr::Member(member) => value_member_object(member.obj.as_ref()),
_ => None,
}
}
fn collect_object_pat_ref_bindings(
object: &swc_core::ecma::ast::ObjectPat,
ref_bindings: &HashSet<Atom>,
bindings: &mut HashSet<Atom>,
) {
for prop in &object.props {
match prop {
swc_core::ecma::ast::ObjectPatProp::KeyValue(key_value) => {
collect_pat_ref_bindings(key_value.value.as_ref(), ref_bindings, bindings);
}
swc_core::ecma::ast::ObjectPatProp::Assign(assign) => {
if ref_bindings.contains(&assign.key.sym) {
bindings.insert(assign.key.sym.clone());
}
}
swc_core::ecma::ast::ObjectPatProp::Rest(_) => {}
}
}
}
fn collect_pat_ref_bindings(pat: &Pat, ref_bindings: &HashSet<Atom>, bindings: &mut HashSet<Atom>) {
match pat {
Pat::Ident(binding) if ref_bindings.contains(&binding.id.sym) => {
bindings.insert(binding.id.sym.clone());
}
Pat::Assign(assign) => {
collect_pat_ref_bindings(assign.left.as_ref(), ref_bindings, bindings)
}
Pat::Ident(_)
| Pat::Array(_)
| Pat::Rest(_)
| Pat::Object(_)
| Pat::Expr(_)
| Pat::Invalid(_) => {}
}
}
fn tuple_member_index(expr: &Expr) -> Option<(Atom, usize)> {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return None;
};
let Expr::Ident(tuple) = unwrap_paren_expr(member.obj.as_ref()) else {
return None;
};
member_prop_index(&member.prop).map(|index| (tuple.sym.clone(), index))
}
fn member_prop_index(prop: &MemberProp) -> Option<usize> {
match prop {
MemberProp::Computed(computed) => match unwrap_paren_expr(computed.expr.as_ref()) {
Expr::Lit(Lit::Num(number)) if number.value >= 0.0 && number.value.fract() == 0.0 => {
Some(number.value as usize)
}
Expr::Lit(Lit::Str(_)) => string_lit(computed.expr.as_ref())?.parse().ok(),
_ => None,
},
MemberProp::Ident(ident) => ident.sym.as_ref().parse().ok(),
MemberProp::PrivateName(_) => None,
}
}
fn composable_ref_prop_exports(
module: &Module,
local_ref_props: &HashMap<Atom, HashSet<Atom>>,
ref_returning_functions: &HashSet<Atom>,
) -> HashMap<String, HashSet<Atom>> {
let mut exports = HashMap::new();
for item in &module.body {
let ModuleItem::ModuleDecl(decl) = item else {
continue;
};
match decl {
ModuleDecl::ExportDecl(export) => {
collect_decl_ref_prop_exports(&export.decl, local_ref_props, &mut exports);
}
ModuleDecl::ExportDefaultExpr(export) => {
collect_default_expr_ref_prop_export(
export.expr.as_ref(),
local_ref_props,
ref_returning_functions,
&mut exports,
);
}
ModuleDecl::ExportDefaultDecl(export) => {
collect_default_decl_ref_prop_export(
&export.decl,
ref_returning_functions,
&mut exports,
);
}
ModuleDecl::ExportNamed(named) if named.src.is_none() => {
for specifier in &named.specifiers {
let ExportSpecifier::Named(named) = specifier else {
continue;
};
let local = Atom::from(module_export_name(&named.orig));
let exported = named
.exported
.as_ref()
.map(module_export_name)
.unwrap_or_else(|| local.to_string());
if let Some(ref_props) = local_ref_props.get(&local) {
exports.insert(exported, ref_props.clone());
}
}
}
_ => {}
}
}
exports
}
fn collect_decl_ref_prop_exports(
decl: &Decl,
local_ref_props: &HashMap<Atom, HashSet<Atom>>,
exports: &mut HashMap<String, HashSet<Atom>>,
) {
match decl {
Decl::Fn(function) => {
if let Some(ref_props) = local_ref_props.get(&function.ident.sym) {
exports.insert(function.ident.sym.to_string(), ref_props.clone());
}
}
Decl::Var(var) => {
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
if let Some(ref_props) = local_ref_props.get(&binding.id.sym) {
exports.insert(binding.id.sym.to_string(), ref_props.clone());
}
}
}
_ => {}
}
}
fn collect_default_expr_ref_prop_export(
expr: &Expr,
local_ref_props: &HashMap<Atom, HashSet<Atom>>,
ref_returning_functions: &HashSet<Atom>,
exports: &mut HashMap<String, HashSet<Atom>>,
) {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => {
if let Some(ref_props) = local_ref_props.get(&ident.sym) {
exports.insert("default".to_string(), ref_props.clone());
}
}
Expr::Arrow(arrow) => {
if let Some(ref_props) = composable_ref_props_from_function(
FunctionLike::Arrow(arrow),
ref_returning_functions,
) {
exports.insert("default".to_string(), ref_props);
}
}
Expr::Fn(function) => {
if let Some(ref_props) = composable_ref_props_from_function(
FunctionLike::Function(&function.function),
ref_returning_functions,
) {
exports.insert("default".to_string(), ref_props);
}
}
_ => {}
}
}
fn collect_default_decl_ref_prop_export(
decl: &DefaultDecl,
ref_returning_functions: &HashSet<Atom>,
exports: &mut HashMap<String, HashSet<Atom>>,
) {
if let DefaultDecl::Fn(function) = decl {
if let Some(ref_props) = composable_ref_props_from_function(
FunctionLike::Function(&function.function),
ref_returning_functions,
) {
exports.insert("default".to_string(), ref_props);
}
}
}
fn member_prop_is_value(prop: &MemberProp) -> bool {
match prop {
MemberProp::Ident(ident) => ident.sym.as_ref() == "value",
MemberProp::Computed(computed) => {
string_lit(computed.expr.as_ref()).as_deref() == Some("value")
}
MemberProp::PrivateName(_) => false,
}
}