crates/core/src/vue_recovery/context.rs
GitHubuse std::collections::{HashMap, HashSet};
use anyhow::Result;
use swc_core::atoms::Atom;
use swc_core::common::{sync::Lrc, SourceMap, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
ArrayLit, ArrowExpr, AssignExpr, AssignTarget, BinaryOp, BlockStmtOrExpr, CallExpr, Callee,
CatchClause, ClassDecl, CondExpr, Decl, ExportDecl, ExportSpecifier, Expr, ExprOrSpread,
FnDecl, Function, Ident, IfStmt, ImportSpecifier, Lit, MemberExpr, MemberProp, Module,
ModuleDecl, ModuleItem, ObjectLit, ObjectPat, ObjectPatProp, Param, ParenExpr, Pat, Prop,
PropName, PropOrSpread, ReturnStmt, SimpleAssignTarget, Stmt, UnaryOp, UpdateExpr, VarDecl,
VarDeclKind, VarDeclarator,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};
use super::expressions::{
clean_expr, clean_setup_stmt, clean_setup_stmt_preserving_ref_values, print_clean_setup_stmt,
print_expr,
};
use super::helpers::{helper_name, VueHelper};
use super::imports;
use super::locals::{
VueSetupLocalBinding, VueSetupRefBinding, VueSetupScriptBinding, VueSetupValueBinding,
};
use super::script_imports::VueScriptImport;
use super::setup_bindings::component_prop_names;
use super::slots::slot_call_binding;
use super::syntax::{
module_export_name, param_binding_ident, prop_name, string_lit, wtf8_to_string,
};
use super::{
RenderSource, VueRecoveryContext, VueRenderChildListBinding, VueRenderChildListSource,
VueRenderSlotBinding,
};
use crate::js_names::{is_likely_generated_alias, is_valid_identifier_name};
use crate::rules::rename_utils::{rename_bindings, BindingRename};
const MAX_INLINE_COMPUTED_TEMPLATE_BINDING_LEN: usize = 80;
struct SetupLocalCandidate {
bindings: Vec<Atom>,
stmt: Stmt,
template_selectable: bool,
setup_order: usize,
always_emit: bool,
preserve_ref_values: bool,
}
#[derive(Clone, Copy)]
pub(super) struct CompiledScriptSetup<'a> {
pub(super) setup_stmts: &'a [Stmt],
pub(super) setup_props: Option<&'a Ident>,
pub(super) setup_props_ctxt: Option<SyntaxContext>,
pub(super) setup_context: Option<&'a Ident>,
pub(super) setup_emit: Option<&'a Ident>,
pub(super) setup_slots: Option<&'a Ident>,
pub(super) setup_expose: Option<&'a Ident>,
}
pub(super) fn compiled_script_setup(
options: Option<&ObjectLit>,
) -> Option<CompiledScriptSetup<'_>> {
let options = options?;
for prop in &options.props {
let PropOrSpread::Prop(prop) = prop else {
continue;
};
match prop.as_ref() {
Prop::Method(method) if prop_name(&method.key).as_deref() == Some("setup") => {
if let Some(setup) = compiled_script_setup_from_function(&method.function) {
return Some(setup);
}
}
Prop::KeyValue(key_value) if prop_name(&key_value.key).as_deref() == Some("setup") => {
match unwrap_paren_expr(key_value.value.as_ref()) {
Expr::Fn(function) => {
if let Some(setup) = compiled_script_setup_from_function(&function.function)
{
return Some(setup);
}
}
Expr::Arrow(arrow) => {
if let Some(setup) = compiled_script_setup_from_arrow(arrow) {
return Some(setup);
}
}
_ => {}
}
}
_ => {}
}
}
None
}
fn compiled_script_setup_from_function(function: &Function) -> Option<CompiledScriptSetup<'_>> {
let body = function.body.as_ref()?;
if !has_script_setup_marker(body) {
return None;
}
let setup_props = function.params.first().and_then(param_binding_ident);
let setup_context = function
.params
.get(1)
.and_then(|param| pat_binding_ident(¶m.pat));
let setup_emit = function
.params
.get(1)
.and_then(|param| named_object_pat_binding(¶m.pat, "emit"));
let setup_slots = function
.params
.get(1)
.and_then(|param| named_object_pat_binding(¶m.pat, "slots"));
let setup_expose = function
.params
.get(1)
.and_then(|param| named_object_pat_binding(¶m.pat, "expose"));
Some(CompiledScriptSetup {
setup_stmts: body.stmts.as_slice(),
setup_props,
setup_props_ctxt: setup_props.map(|ident| ident.ctxt),
setup_context,
setup_emit,
setup_slots,
setup_expose,
})
}
fn compiled_script_setup_from_arrow(arrow: &ArrowExpr) -> Option<CompiledScriptSetup<'_>> {
let BlockStmtOrExpr::BlockStmt(body) = arrow.body.as_ref() else {
return None;
};
if !has_script_setup_marker(body) {
return None;
}
let setup_props = arrow.params.first().and_then(pat_binding_ident);
let setup_context = arrow.params.get(1).and_then(pat_binding_ident);
let setup_emit = arrow
.params
.get(1)
.and_then(|pat| named_object_pat_binding(pat, "emit"));
let setup_slots = arrow
.params
.get(1)
.and_then(|pat| named_object_pat_binding(pat, "slots"));
let setup_expose = arrow
.params
.get(1)
.and_then(|pat| named_object_pat_binding(pat, "expose"));
Some(CompiledScriptSetup {
setup_stmts: body.stmts.as_slice(),
setup_props,
setup_props_ctxt: setup_props.map(|ident| ident.ctxt),
setup_context,
setup_emit,
setup_slots,
setup_expose,
})
}
fn pat_binding_ident(pat: &Pat) -> Option<&Ident> {
match pat {
Pat::Ident(binding) => Some(&binding.id),
_ => None,
}
}
fn named_object_pat_binding<'a>(pat: &'a Pat, name: &str) -> Option<&'a Ident> {
let Pat::Object(object) = pat else {
return None;
};
object.props.iter().find_map(|prop| match prop {
ObjectPatProp::KeyValue(key_value)
if prop_name(&key_value.key).as_deref() == Some(name) =>
{
pat_binding_ident(key_value.value.as_ref())
}
ObjectPatProp::Assign(assign) if assign.key.sym.as_ref() == name => Some(&assign.key),
_ => None,
})
}
fn has_script_setup_marker(body: &swc_core::ecma::ast::BlockStmt) -> bool {
struct MarkerFinder(bool);
impl Visit for MarkerFinder {
fn visit_call_expr(&mut self, call: &CallExpr) {
if script_setup_marker_target(call).is_some() {
self.0 = true;
return;
}
call.visit_children_with(self);
}
}
let mut finder = MarkerFinder(false);
body.visit_with(&mut finder);
finder.0
}
fn is_compiled_setup_artifact_stmt(
stmt: &Stmt,
setup_expose: Option<&(Atom, SyntaxContext)>,
) -> bool {
if let (Stmt::Expr(expr_stmt), Some((expose_name, expose_ctxt))) = (stmt, setup_expose) {
if let Expr::Call(call) = expr_stmt.expr.as_ref() {
if call.args.is_empty()
&& matches!(&call.callee, Callee::Expr(callee) if matches!(callee.as_ref(), Expr::Ident(ident) if ident.sym == *expose_name && ident.ctxt == *expose_ctxt))
{
return true;
}
}
}
matches!(stmt, Stmt::Expr(expr_stmt) if matches!(unwrap_paren_expr(expr_stmt.expr.as_ref()), Expr::Call(call) if script_setup_marker_target(call).is_some()))
}
fn compiled_setup_return_binding(stmts: &[Stmt]) -> Option<(Atom, SyntaxContext)> {
stmts.iter().find_map(|stmt| {
let Stmt::Expr(expr_stmt) = stmt else {
return None;
};
let Expr::Call(call) = unwrap_paren_expr(expr_stmt.expr.as_ref()) else {
return None;
};
script_setup_marker_target(call).map(|ident| (ident.sym.clone(), ident.ctxt))
})
}
fn compiled_setup_return_values(
stmts: &[Stmt],
return_binding: &(Atom, SyntaxContext),
) -> Vec<(Atom, Box<Expr>, usize)> {
stmts
.iter()
.enumerate()
.filter_map(|stmt| match stmt {
(setup_order, Stmt::Decl(Decl::Var(var))) => Some((setup_order, var.decls.as_slice())),
_ => None,
})
.find_map(|(setup_order, decls)| {
decls.iter().find_map(|decl| {
let Pat::Ident(binding) = &decl.name else {
return None;
};
if binding.id.sym != return_binding.0 || binding.id.ctxt != return_binding.1 {
return None;
}
let Expr::Object(object) = decl.init.as_deref()? else {
return None;
};
Some((object, setup_order))
})
})
.map(|(object, setup_order)| {
object
.props
.iter()
.filter_map(|prop| {
let PropOrSpread::Prop(prop) = prop else {
return None;
};
let Prop::KeyValue(key_value) = prop.as_ref() else {
return None;
};
let name = prop_name(&key_value.key)?;
is_valid_identifier_name(name.as_ref())
.then(|| (Atom::from(name), key_value.value.clone(), setup_order))
})
.collect()
})
.unwrap_or_default()
}
fn is_undefined_placeholder(expr: &Expr) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => ident.sym.as_ref() == "undefined",
Expr::Unary(unary) => unary.op == UnaryOp::Void,
_ => false,
}
}
fn script_setup_marker_target(call: &CallExpr) -> Option<&Ident> {
if call.args.len() != 3 || call.args.iter().any(|arg| arg.spread.is_some()) {
return None;
}
let Callee::Expr(callee) = &call.callee else {
return None;
};
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !matches!(member.obj.as_ref(), Expr::Ident(object) if object.sym.as_ref() == "Object") {
return None;
}
if !matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "defineProperty") {
return None;
}
let has_marker_name = call.args.get(1).is_some_and(
|arg| matches!(arg.expr.as_ref(), Expr::Lit(Lit::Str(value)) if wtf8_to_string(&value.value) == "__isScriptSetup"),
);
if !has_marker_name {
return None;
}
let Expr::Object(descriptor) = call.args.get(2)?.expr.as_ref() else {
return None;
};
if !object_bool_prop(descriptor, "enumerable", false)
|| !object_bool_prop(descriptor, "value", true)
{
return None;
}
call.args
.first()
.and_then(|arg| ident_expr(unwrap_paren_expr(arg.expr.as_ref())))
}
fn object_bool_prop(object: &ObjectLit, name: &str, expected: bool) -> bool {
object.props.iter().any(|prop| {
let PropOrSpread::Prop(prop) = prop else {
return false;
};
matches!(
prop.as_ref(),
Prop::KeyValue(key_value)
if prop_name(&key_value.key).as_deref() == Some(name)
&& matches!(key_value.value.as_ref(), Expr::Lit(Lit::Bool(value)) if value.value == expected)
)
})
}
/// Record the resolved `SyntaxContext` of every top-level binding (imports plus
/// `var`/`fn`/`class` declarations). Helper recognition uses it to tell a
/// genuine reference to an imported Vue helper apart from an inner-scope local
/// that reuses the (minified) name; alias renaming uses it to build
/// `SyntaxContext`-keyed `BindingRename`s for `rename_utils::BindingRenamer`.
fn top_level_binding_ctxts(module: &Module) -> HashMap<Atom, SyntaxContext> {
let mut ctxts = HashMap::new();
for item in &module.body {
match item {
ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {
for specifier in &import.specifiers {
let local = match specifier {
ImportSpecifier::Named(named) => &named.local,
ImportSpecifier::Default(default) => &default.local,
ImportSpecifier::Namespace(namespace) => &namespace.local,
};
ctxts.insert(local.sym.clone(), local.ctxt);
}
}
ModuleItem::Stmt(Stmt::Decl(decl))
| ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl { decl, .. })) => {
record_decl_binding_ctxts(decl, &mut ctxts);
}
_ => {}
}
}
ctxts
}
fn record_decl_binding_ctxts(decl: &Decl, ctxts: &mut HashMap<Atom, SyntaxContext>) {
match decl {
Decl::Fn(function) => {
ctxts.insert(function.ident.sym.clone(), function.ident.ctxt);
}
Decl::Class(class) => {
ctxts.insert(class.ident.sym.clone(), class.ident.ctxt);
}
Decl::Var(var) => {
for declarator in &var.decls {
record_pat_binding_ctxts(&declarator.name, ctxts);
}
}
_ => {}
}
}
fn record_pat_binding_ctxts(pat: &Pat, ctxts: &mut HashMap<Atom, SyntaxContext>) {
match pat {
Pat::Ident(binding) => {
ctxts.insert(binding.id.sym.clone(), binding.id.ctxt);
}
Pat::Array(array) => {
for elem in array.elems.iter().flatten() {
record_pat_binding_ctxts(elem, ctxts);
}
}
Pat::Object(object) => {
for prop in &object.props {
match prop {
ObjectPatProp::KeyValue(key_value) => {
record_pat_binding_ctxts(&key_value.value, ctxts)
}
ObjectPatProp::Assign(assign) => {
ctxts.insert(assign.key.id.sym.clone(), assign.key.id.ctxt);
}
ObjectPatProp::Rest(rest) => record_pat_binding_ctxts(&rest.arg, ctxts),
}
}
}
Pat::Rest(rest) => record_pat_binding_ctxts(&rest.arg, ctxts),
Pat::Assign(assign) => record_pat_binding_ctxts(&assign.left, ctxts),
Pat::Expr(_) | Pat::Invalid(_) => {}
}
}
/// Collect each pattern-bound ident as a `(name, SyntaxContext)` pair. Mirrors
/// [`record_pat_binding_ctxts`] but keeps distinct contexts for the same name so
/// candidate sets can be matched against a resolved reference's own binding
/// identity rather than by name alone.
fn collect_pat_binding_idents(pat: &Pat, bindings: &mut HashSet<(Atom, SyntaxContext)>) {
match pat {
Pat::Ident(binding) => {
bindings.insert((binding.id.sym.clone(), binding.id.ctxt));
}
Pat::Array(array) => {
for elem in array.elems.iter().flatten() {
collect_pat_binding_idents(elem, bindings);
}
}
Pat::Object(object) => {
for prop in &object.props {
match prop {
ObjectPatProp::KeyValue(key_value) => {
collect_pat_binding_idents(&key_value.value, bindings)
}
ObjectPatProp::Assign(assign) => {
bindings.insert((assign.key.id.sym.clone(), assign.key.id.ctxt));
}
ObjectPatProp::Rest(rest) => collect_pat_binding_idents(&rest.arg, bindings),
}
}
}
Pat::Rest(rest) => collect_pat_binding_idents(&rest.arg, bindings),
Pat::Assign(assign) => collect_pat_binding_idents(&assign.left, bindings),
Pat::Expr(_) | Pat::Invalid(_) => {}
}
}
pub(super) fn collect_context(
module: &Module,
cm: Lrc<SourceMap>,
component_bindings: HashMap<Atom, String>,
imported_composable_ref_props: HashMap<Atom, HashSet<Atom>>,
) -> VueRecoveryContext {
let default_exported_bindings = default_exported_bindings(module);
let mut ctx = VueRecoveryContext {
cm,
component_bindings,
imported_composable_ref_props,
..Default::default()
};
ctx.top_level_binding_ctxts = top_level_binding_ctxts(module);
for item in &module.body {
match item {
ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {
let source = wtf8_to_string(&import.src.value);
let imported_component = vue_component_name_from_source(&source);
for specifier in &import.specifiers {
match specifier {
ImportSpecifier::Named(named) => {
if let Some(component) = &imported_component {
ctx.component_bindings
.entry(named.local.sym.clone())
.or_insert_with(|| {
preferred_imported_component_name(
&named.local.sym,
component,
)
});
}
let imported = named
.imported
.as_ref()
.map(module_export_name)
.unwrap_or_else(|| named.local.sym.to_string());
if source != "vue" {
ctx.script_imports.insert(
named.local.sym.clone(),
VueScriptImport::Named {
source: source.clone(),
imported: imported.clone(),
},
);
}
if source == "pinia" && imported == "storeToRefs" {
ctx.vue_helpers
.insert(named.local.sym.clone(), VueHelper::Other(imported));
continue;
}
if source != "vue" {
if is_vue_helper_candidate_source(&source) {
ctx.vue_helper_candidates.insert(named.local.sym.clone());
}
continue;
}
ctx.vue_helpers.insert(
named.local.sym.clone(),
VueHelper::from_imported_name(imported),
);
}
ImportSpecifier::Default(default) => {
if source != "vue" {
ctx.script_imports.insert(
default.local.sym.clone(),
VueScriptImport::Default {
source: source.clone(),
},
);
}
if let Some(component) = &imported_component {
ctx.component_bindings
.entry(default.local.sym.clone())
.or_insert_with(|| {
preferred_imported_component_name(
&default.local.sym,
component,
)
});
}
}
ImportSpecifier::Namespace(namespace) => {
if source == "vue" || is_vue_helper_candidate_source(&source) {
ctx.vue_namespaces.insert(namespace.local.sym.clone());
}
if source != "vue" {
ctx.script_imports.insert(
namespace.local.sym.clone(),
VueScriptImport::Namespace {
source: source.clone(),
},
);
}
if let Some(component) = &imported_component {
ctx.component_bindings
.entry(namespace.local.sym.clone())
.or_insert_with(|| {
preferred_imported_component_name(
&namespace.local.sym,
component,
)
});
}
}
}
}
}
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => {
collect_var_decl_context(var, &mut ctx, &default_exported_bindings);
}
ModuleItem::Stmt(Stmt::Decl(Decl::Fn(function))) => {
collect_fn_decl_context(function, &mut ctx);
}
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => match &export.decl {
Decl::Var(var) => {
collect_var_decl_context(var, &mut ctx, &default_exported_bindings);
}
Decl::Fn(function) => collect_fn_decl_context(function, &mut ctx),
_ => {}
},
_ => {}
}
}
ctx
}
fn collect_fn_decl_context(function: &FnDecl, ctx: &mut VueRecoveryContext) {
if is_slot_result_normalizer_function(&function.function) {
ctx.slot_result_normalizers
.insert(function.ident.sym.clone());
}
}
fn is_slot_result_normalizer_function(function: &Function) -> bool {
let Some(param) = function.params.first() else {
return false;
};
if function.params.len() != 1 {
return false;
}
let Pat::Ident(param) = ¶m.pat else {
return false;
};
let Some(body) = &function.body else {
return false;
};
let [Stmt::If(if_stmt), Stmt::Return(final_return)] = body.stmts.as_slice() else {
return false;
};
if !is_length_one_test(if_stmt.test.as_ref(), ¶m.id.sym) {
return false;
}
if !if_stmt
.cons
.as_ref()
.is_return_with(|expr| is_member_index_expr(expr, ¶m.id.sym, 0.0))
{
return false;
}
final_return
.arg
.as_deref()
.is_some_and(|expr| is_ident_expr(expr, ¶m.id.sym))
}
trait ReturnStmtExt {
fn is_return_with(&self, predicate: impl FnOnce(&Expr) -> bool) -> bool;
}
impl ReturnStmtExt for Stmt {
fn is_return_with(&self, predicate: impl FnOnce(&Expr) -> bool) -> bool {
match self {
Stmt::Return(return_stmt) => return_stmt.arg.as_deref().is_some_and(predicate),
Stmt::Block(block) => match block.stmts.as_slice() {
[Stmt::Return(return_stmt)] => return_stmt.arg.as_deref().is_some_and(predicate),
_ => false,
},
_ => false,
}
}
}
fn is_length_one_test(expr: &Expr, param: &Atom) -> bool {
let Expr::Bin(bin) = unwrap_paren_expr(expr) else {
return false;
};
if !matches!(bin.op, BinaryOp::EqEq | BinaryOp::EqEqEq) {
return false;
}
(is_member_prop_expr(bin.left.as_ref(), param, "length")
&& is_number_lit(bin.right.as_ref(), 1.0))
|| (is_member_prop_expr(bin.right.as_ref(), param, "length")
&& is_number_lit(bin.left.as_ref(), 1.0))
}
fn is_member_prop_expr(expr: &Expr, object: &Atom, prop: &str) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
is_ident_expr(member.obj.as_ref(), object) && member_prop_is_named(&member.prop, prop)
}
fn is_member_index_expr(expr: &Expr, object: &Atom, index: f64) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
if !is_ident_expr(member.obj.as_ref(), object) {
return false;
}
let MemberProp::Computed(computed) = &member.prop else {
return false;
};
is_number_lit(computed.expr.as_ref(), index)
}
fn is_ident_expr(expr: &Expr, sym: &Atom) -> bool {
matches!(unwrap_paren_expr(expr), Expr::Ident(ident) if &ident.sym == sym)
}
fn is_number_lit(expr: &Expr, value: f64) -> bool {
matches!(unwrap_paren_expr(expr), Expr::Lit(Lit::Num(number)) if number.value == value)
}
fn default_exported_bindings(module: &Module) -> HashSet<Atom> {
let mut bindings = HashSet::new();
for item in &module.body {
let ModuleItem::ModuleDecl(decl) = item else {
continue;
};
match decl {
ModuleDecl::ExportDefaultExpr(export) => {
if let Expr::Ident(ident) = export.expr.as_ref() {
bindings.insert(ident.sym.clone());
}
}
ModuleDecl::ExportNamed(export) if export.src.is_none() => {
for specifier in &export.specifiers {
let ExportSpecifier::Named(named) = specifier else {
continue;
};
let exported = named
.exported
.as_ref()
.map(module_export_name)
.unwrap_or_else(|| module_export_name(&named.orig));
if exported == "default" {
bindings.insert(Atom::from(module_export_name(&named.orig)));
}
}
}
_ => {}
}
}
bindings
}
pub(super) fn collect_script_local_context(
module: &Module,
ctx: &mut VueRecoveryContext,
) -> Result<()> {
let reserved_bindings = script_local_reserved_bindings(module, ctx);
let mut used_bindings = reserved_bindings.clone();
used_bindings.extend(ctx.script_imports.keys().cloned());
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Decl(decl)) => {
collect_script_local_decl(decl, ctx, &reserved_bindings, &mut used_bindings)?
}
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {
collect_script_local_decl(
&export.decl,
ctx,
&reserved_bindings,
&mut used_bindings,
)?;
}
_ => {}
}
}
Ok(())
}
fn script_local_reserved_bindings(module: &Module, ctx: &VueRecoveryContext) -> HashSet<Atom> {
let mut reserved = HashSet::new();
reserved.extend(
ctx.setup_script_bindings
.iter()
.map(|binding| binding.binding.clone()),
);
reserved.extend(
ctx.setup_local_bindings
.iter()
.flat_map(|binding| binding.emitted_bindings.iter().cloned()),
);
reserved.extend(
ctx.setup_ref_script_bindings
.iter()
.map(|binding| binding.binding.clone()),
);
reserved.extend(ctx.bindings.values.keys().cloned());
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Decl(decl)) => collect_decl_bindings(decl, &mut reserved),
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {
collect_decl_bindings(&export.decl, &mut reserved);
}
_ => {}
}
}
reserved
}
fn collect_decl_bindings(decl: &Decl, bindings: &mut HashSet<Atom>) {
match decl {
Decl::Fn(function) => {
bindings.insert(function.ident.sym.clone());
}
Decl::Class(class) => {
bindings.insert(class.ident.sym.clone());
}
Decl::Var(var) => {
for declarator in &var.decls {
collect_pat_bindings(&declarator.name, bindings);
}
}
_ => {}
}
}
fn emitted_stmt_bindings(source: &str, ctx: &VueRecoveryContext, fallback: &[Atom]) -> Vec<Atom> {
let bindings = emitted_decl_bindings(source, ctx);
if bindings.is_empty() {
fallback.to_vec()
} else {
bindings
}
}
fn emitted_decl_bindings(source: &str, ctx: &VueRecoveryContext) -> Vec<Atom> {
let Ok(module) = super::parse_module(source, ctx.cm.clone()) else {
return Vec::new();
};
let mut bindings = HashSet::new();
for item in &module.body {
match item {
ModuleItem::Stmt(Stmt::Decl(decl)) => collect_decl_bindings(decl, &mut bindings),
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {
collect_decl_bindings(&export.decl, &mut bindings);
}
_ => {}
}
}
let mut bindings = bindings.into_iter().collect::<Vec<_>>();
bindings.sort_by(|left, right| left.as_ref().cmp(right.as_ref()));
bindings.dedup();
bindings
}
fn collect_script_local_decl(
decl: &Decl,
ctx: &mut VueRecoveryContext,
reserved_bindings: &HashSet<Atom>,
used_bindings: &mut HashSet<Atom>,
) -> Result<()> {
match decl {
Decl::Fn(function) => push_script_local_binding(
ctx,
vec![function.ident.sym.clone()],
Stmt::Decl(Decl::Fn(function.clone())),
reserved_bindings,
used_bindings,
),
Decl::Class(class) => push_script_local_binding(
ctx,
vec![class.ident.sym.clone()],
Stmt::Decl(Decl::Class(class.clone())),
reserved_bindings,
used_bindings,
),
Decl::Var(var) => {
for declarator in &var.decls {
if declarator.init.as_deref().is_some_and(|init| {
component_name_from_init(init, &ctx.component_bindings).is_some()
}) {
continue;
}
let mut bindings = HashSet::new();
collect_pat_bindings(&declarator.name, &mut bindings);
if bindings.is_empty() {
continue;
}
let mut single_var = var.as_ref().clone();
single_var.decls = vec![declarator.clone()];
let mut bindings = bindings.into_iter().collect::<Vec<_>>();
bindings.sort_by(|left, right| left.as_ref().cmp(right.as_ref()));
push_script_local_binding(
ctx,
bindings,
Stmt::Decl(Decl::Var(Box::new(single_var))),
reserved_bindings,
used_bindings,
)?;
}
Ok(())
}
_ => Ok(()),
}
}
fn push_script_local_binding(
ctx: &mut VueRecoveryContext,
bindings: Vec<Atom>,
mut stmt: Stmt,
reserved_bindings: &HashSet<Atom>,
used_bindings: &mut HashSet<Atom>,
) -> Result<()> {
let cleaned_stmt = clean_setup_stmt(&stmt, ctx);
let mut source = print_clean_setup_stmt(&cleaned_stmt, ctx)?;
if is_transpiler_runtime_helper_source(&source) {
return Ok(());
}
let import_aliases = colliding_import_aliases(&stmt, ctx, reserved_bindings, used_bindings);
if !import_aliases.is_empty() {
rename_bindings(&mut stmt, &binding_renames(&import_aliases, ctx));
let cleaned_stmt = clean_setup_stmt(&stmt, ctx);
source = print_clean_setup_stmt(&cleaned_stmt, ctx)?;
}
if !source.is_empty() {
let cleaned_stmt = clean_setup_stmt(&stmt, ctx);
let emitted_bindings = emitted_stmt_bindings(&source, ctx, &bindings);
ctx.script_local_bindings.push(VueSetupLocalBinding {
bindings,
emitted_bindings,
refs: stmt_ident_refs(&cleaned_stmt),
source,
import_refs: stmt_import_refs(&cleaned_stmt, &ctx.script_imports),
stmt: cleaned_stmt,
module_scope: true,
template_selectable: true,
setup_order: 0,
always_emit: false,
preserve_ref_values: false,
});
}
Ok(())
}
pub(super) fn render_local_declaration_with_aliases(
ctx: &VueRecoveryContext,
declaration: &VueSetupLocalBinding,
aliases: &HashMap<Atom, Atom>,
props_binding: Option<&str>,
) -> Result<VueSetupLocalBinding> {
let mut stmt = declaration.stmt.clone();
if declaration.module_scope && !aliases.is_empty() {
rename_bindings(&mut stmt, &binding_renames(aliases, ctx));
}
let mut cleaned_stmt = if declaration.preserve_ref_values {
clean_setup_stmt_preserving_ref_values(&stmt, ctx)
} else {
clean_setup_stmt(&stmt, ctx)
};
if !declaration.module_scope {
if let Some(props_binding) = props_binding {
rename_bindings(&mut cleaned_stmt, &setup_props_renames(ctx, props_binding));
}
}
let source = print_clean_setup_stmt(&cleaned_stmt, ctx)?;
let bindings = if declaration.module_scope {
declaration
.bindings
.iter()
.map(|binding| {
aliases
.get(binding)
.cloned()
.unwrap_or_else(|| binding.clone())
})
.collect()
} else {
declaration.bindings.clone()
};
let emitted_bindings = emitted_stmt_bindings(&source, ctx, &bindings);
Ok(VueSetupLocalBinding {
bindings,
emitted_bindings,
refs: stmt_ident_refs(&cleaned_stmt),
source,
import_refs: stmt_import_refs(&cleaned_stmt, &ctx.script_imports),
stmt: cleaned_stmt,
module_scope: declaration.module_scope,
template_selectable: declaration.template_selectable,
setup_order: declaration.setup_order,
always_emit: declaration.always_emit,
preserve_ref_values: declaration.preserve_ref_values,
})
}
/// Renames for the setup `props` sources — the setup parameter
/// (`setup_props_context`) and every `setup_props_aliases` entry — onto the
/// emitted `props_binding`, keyed on each source's recorded `(name, ctxt)`.
/// Replaces the former bespoke `SetupPropsRefRewriter` visitor; `BindingRenamer`
/// preserves context and expands `Prop::Shorthand`, and matches only the
/// resolved props binding, never an inner-scope local of the same name.
fn setup_props_renames(ctx: &VueRecoveryContext, props_binding: &str) -> Vec<BindingRename> {
let new = Atom::from(props_binding.to_string());
let mut renames = Vec::new();
if let (Some(name), Some(ctxt)) = (&ctx.setup_props_context, ctx.setup_props_context_ctxt) {
renames.push(BindingRename {
old: (name.clone(), ctxt),
new: new.clone(),
});
}
for (alias, ctxt) in &ctx.setup_props_alias_ctxts {
renames.push(BindingRename {
old: (alias.clone(), *ctxt),
new: new.clone(),
});
}
renames
}
/// Convert a name-keyed alias map into `SyntaxContext`-keyed renames for
/// `rename_utils::BindingRenamer`, which rewrites both the declaration and every
/// resolved reference (and expands shorthand) without the hand-rolled scope
/// tracking the old `ImportAliasRenamer`/`rename_top_level_decl_bindings` needed.
/// Names without a recorded top-level context are skipped (they are not
/// top-level bindings, so the alias would not apply).
fn binding_renames(aliases: &HashMap<Atom, Atom>, ctx: &VueRecoveryContext) -> Vec<BindingRename> {
aliases
.iter()
.filter_map(|(old, new)| {
ctx.top_level_binding_ctxts
.get(old)
.map(|ctxt| BindingRename {
old: (old.clone(), *ctxt),
new: new.clone(),
})
})
.collect()
}
/// Renames for the setup-scope aliases in `ctx.bindings.aliases`, keyed on the
/// recorded `(name, ctxt)` of each alias source so `BindingRenamer` rewrites only
/// the aliased binding's references and never an inner-scope local of the same
/// name. Replaces the former bespoke `SetupAliasCleaner` visitor. Falls back to a
/// top-level binding context for aliases that originate at module scope.
pub(super) fn setup_alias_renames(ctx: &VueRecoveryContext) -> Vec<BindingRename> {
ctx.bindings
.aliases
.iter()
.filter_map(|(from, to)| {
ctx.bindings
.alias_ctxts
.get(from)
.or_else(|| ctx.top_level_binding_ctxts.get(from))
.map(|ctxt| BindingRename {
old: (from.clone(), *ctxt),
new: to.clone(),
})
})
.collect()
}
fn is_transpiler_runtime_helper_source(source: &str) -> bool {
source.contains("suspendedStart")
&& source.contains("_invoke")
&& (source.contains("@@iterator") || source.contains("__await"))
}
fn is_vue_helper_candidate_source(source: &str) -> bool {
if source.contains("runtime-core") || source.contains("runtime-dom") {
return true;
}
if is_vue_adjacent_package_source(source) {
return false;
}
if is_bare_import_source(source) {
return false;
}
source.contains("vue")
}
fn is_vue_adjacent_package_source(source: &str) -> bool {
let source = source.to_ascii_lowercase();
source.contains("vueuse")
|| source.contains("vue-router")
|| source.contains("vuex")
|| source.contains("vue-i18n")
|| source.contains("vue-demi")
|| source.contains("vue-query")
}
fn is_bare_import_source(source: &str) -> bool {
!source.starts_with('.')
&& !source.starts_with('/')
&& !source.starts_with("file:")
&& !source.starts_with("http:")
&& !source.starts_with("https:")
}
fn colliding_import_aliases(
stmt: &Stmt,
ctx: &mut VueRecoveryContext,
reserved_bindings: &HashSet<Atom>,
used_bindings: &mut HashSet<Atom>,
) -> HashMap<Atom, Atom> {
let import_refs = stmt_import_refs(stmt, &ctx.script_imports);
let mut aliases = HashMap::new();
for import_ref in import_refs {
if !reserved_bindings.contains(&import_ref) {
continue;
}
let Some(import) = ctx.script_imports.get(&import_ref).cloned() else {
continue;
};
let alias = unique_script_import_alias(&import_ref, used_bindings);
ctx.script_imports.insert(alias.clone(), import);
aliases.insert(import_ref, alias);
}
aliases
}
fn unique_script_import_alias(binding: &Atom, used_bindings: &mut HashSet<Atom>) -> Atom {
let mut index = 1;
loop {
let candidate = Atom::from(format!("{}_{index}", binding.as_ref()));
if used_bindings.insert(candidate.clone()) {
return candidate;
}
index += 1;
}
}
fn collect_var_decl_context(
var: &VarDecl,
ctx: &mut VueRecoveryContext,
default_exported_bindings: &HashSet<Atom>,
) {
if !matches!(var.kind, VarDeclKind::Const | VarDeclKind::Var) {
return;
}
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
if let Expr::Object(object) = init {
ctx.object_bindings
.insert(binding.id.sym.clone(), object.clone());
}
if is_vue_fragment_symbol_init(init) {
ctx.vue_helpers
.insert(binding.id.sym.clone(), VueHelper::Fragment);
}
if is_likely_vue_runtime_require_namespace(&binding.id.sym, init) {
ctx.vue_namespaces.insert(binding.id.sym.clone());
}
if let Some(ref_props) = provider_ref_props_from_init(init, ctx) {
ctx.provider_ref_bindings
.insert(binding.id.sym.clone(), ref_props);
}
if let Some(component) = component_name_from_init(init, &ctx.component_bindings) {
ctx.component_bindings
.insert(binding.id.sym.clone(), component);
}
if binding.id.sym.as_ref() == "__sfc__"
|| default_exported_bindings.contains(&binding.id.sym)
{
if let Some(object) = component_options_from_init(init) {
ctx.component_options = Some(object.clone());
}
}
}
}
fn is_vue_fragment_symbol_init(expr: &Expr) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
let Callee::Expr(callee) = &call.callee else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
let Expr::Ident(object) = member.obj.as_ref() else {
return false;
};
if object.sym.as_ref() != "Symbol" {
return false;
}
let MemberProp::Ident(prop) = &member.prop else {
return false;
};
if prop.sym.as_ref() != "for" {
return false;
}
call.args
.first()
.and_then(|arg| string_lit(arg.expr.as_ref()))
.as_deref()
== Some("v-fgt")
}
fn is_likely_vue_runtime_require_namespace(binding: &Atom, expr: &Expr) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
if !call_callee_ident(call)
.is_some_and(|callee| matches!(callee.sym.as_ref(), "require" | "__webpack_require__"))
{
return false;
}
if let Some(source) = call
.args
.first()
.and_then(|arg| string_lit(arg.expr.as_ref()))
{
return source == "vue"
|| source.contains("@vue/runtime")
|| source.contains("vue/dist")
|| source.contains("vue.runtime");
}
let binding = binding.to_string().to_ascii_lowercase();
(binding.contains("vue") && binding.contains("runtime"))
|| binding.contains("vue__webpack_imported_module")
}
pub(super) fn component_options_from_init(expr: &Expr) -> Option<&ObjectLit> {
match unwrap_paren_expr(expr) {
Expr::Object(object) => Some(object),
Expr::Call(call) => {
call.args
.first()
.and_then(|arg| match unwrap_paren_expr(arg.expr.as_ref()) {
Expr::Object(object) => Some(object),
_ => None,
})
}
_ => None,
}
}
pub(super) fn component_name_from_init(
expr: &Expr,
component_bindings: &HashMap<Atom, String>,
) -> Option<String> {
match unwrap_paren_expr(expr) {
Expr::Object(object) => component_name_from_options(object),
Expr::Call(call) => call.args.first().and_then(|arg| match arg.expr.as_ref() {
Expr::Object(object) => component_name_from_options(object),
Expr::Ident(ident) => component_bindings.get(&ident.sym).cloned(),
Expr::Call(_) | Expr::Paren(_) => {
component_name_from_init(arg.expr.as_ref(), component_bindings)
}
_ => None,
}),
_ => None,
}
}
pub(super) fn component_name_from_options(object: &ObjectLit) -> Option<String> {
object.props.iter().find_map(|prop| {
let PropOrSpread::Prop(prop) = prop else {
return None;
};
let Prop::KeyValue(key_value) = prop.as_ref() else {
return None;
};
matches!(
prop_name(&key_value.key).as_deref(),
Some("__name" | "name")
)
.then(|| string_lit(key_value.value.as_ref()))
.flatten()
})
}
fn vue_component_name_from_source(source: &str) -> Option<String> {
let file = source
.rsplit(['/', '\\'])
.next()
.unwrap_or(source)
.trim_start_matches("./");
if source.contains(".vue") {
let name = file.split(".vue").next()?;
return (!name.is_empty()).then(|| name.to_string());
}
let stem = file
.strip_suffix(".mjs")
.or_else(|| file.strip_suffix(".js"))?;
let name = stem
.split('-')
.next()
.unwrap_or(stem)
.split('.')
.next()
.unwrap_or(stem);
let starts_with_uppercase = name
.chars()
.next()
.is_some_and(|ch| ch.is_ascii_uppercase());
(starts_with_uppercase && !name.is_empty()).then(|| name.to_string())
}
fn preferred_imported_component_name(local: &Atom, inferred: &str) -> String {
let local = local.as_ref();
let looks_authored = !is_likely_generated_alias(local)
&& local
.chars()
.next()
.is_some_and(|ch| ch.is_ascii_uppercase())
&& local
.chars()
.all(|ch| ch.is_ascii_alphanumeric() || ch == '$');
if looks_authored {
local.to_string()
} else {
inferred.to_string()
}
}
pub(super) fn infer_render_helpers(render: RenderSource<'_>, ctx: &mut VueRecoveryContext) {
if ctx.vue_helper_candidates.is_empty() && ctx.vue_helpers.is_empty() {
return;
}
let mut inference = HelperInference {
candidates: &ctx.vue_helper_candidates,
known_helpers: &ctx.vue_helpers,
import_ctxts: &ctx.top_level_binding_ctxts,
unresolved_ctxt: ctx.unresolved_ctxt,
inferred: HashMap::new(),
prop_value_depth: 0,
vnode_child_depth: 0,
};
match render {
RenderSource::Function { render, .. } => {
if let Some(body) = render.function.body.as_ref() {
body.visit_with(&mut inference);
}
}
RenderSource::SetupArrow { render, .. } => render.body.visit_with(&mut inference),
}
for (local, helper) in inference.inferred {
ctx.vue_helpers.entry(local).or_insert(helper);
}
}
struct HelperInference<'a> {
candidates: &'a std::collections::HashSet<Atom>,
known_helpers: &'a HashMap<Atom, VueHelper>,
import_ctxts: &'a HashMap<Atom, SyntaxContext>,
unresolved_ctxt: SyntaxContext,
inferred: HashMap<Atom, VueHelper>,
prop_value_depth: usize,
vnode_child_depth: usize,
}
impl HelperInference<'_> {
/// True if `ident` refers to the imported binding of its name (matching the
/// import's resolved `SyntaxContext`), not an inner-scope local reusing the
/// name. Every helper candidate/known helper is an import, so recognition
/// requires this rather than falling back to name-only matching.
fn import_resolves(&self, ident: &Ident) -> bool {
self.import_ctxts
.get(&ident.sym)
.is_some_and(|ctxt| *ctxt == ident.ctxt)
}
/// A helper candidate reference that resolves to its import binding.
fn is_candidate(&self, ident: &Ident) -> bool {
self.candidates.contains(&ident.sym) && self.import_resolves(ident)
}
}
impl Visit for HelperInference<'_> {
fn visit_if_stmt(&mut self, if_stmt: &IfStmt) {
self.infer_condition_unref_expr(if_stmt.test.as_ref());
if_stmt.visit_children_with(self);
}
fn visit_cond_expr(&mut self, cond: &CondExpr) {
self.infer_condition_unref_expr(cond.test.as_ref());
cond.visit_children_with(self);
}
fn visit_member_expr(&mut self, member: &MemberExpr) {
self.infer_unref_expr(member.obj.as_ref());
member.visit_children_with(self);
}
fn visit_call_expr(&mut self, call: &CallExpr) {
if self.prop_value_depth > 0 {
self.infer_render_prop_unref_call(call);
}
if self.vnode_child_depth > 0 {
self.infer_vnode_child_helper_call(call);
}
if let Callee::Expr(callee) = &call.callee {
self.infer_unref_expr(callee.as_ref());
}
if let Some((callee, inferred_fragment)) = self.fragment_block_call(call) {
self.inferred
.insert(callee.sym.clone(), VueHelper::CreateElementBlock);
if let Some(fragment) = inferred_fragment {
self.inferred
.insert(fragment.sym.clone(), VueHelper::Fragment);
}
}
if let Some(callee) = self.with_directives_call(call) {
self.inferred
.entry(callee.sym.clone())
.or_insert(VueHelper::WithDirectives);
}
if let Some(callee) = call_callee_ident(call) {
if self.is_candidate(callee) {
if let Some(helper) = infer_call_helper(call) {
self.inferred.entry(callee.sym.clone()).or_insert(helper);
}
}
}
if let Some(VueHelper::CreateElementBlock | VueHelper::CreateElementVNode) =
self.call_helper(call)
{
if let Some(fragment) = call
.args
.first()
.and_then(|arg| ident_expr(arg.expr.as_ref()))
.filter(|&ident| self.is_candidate(ident))
{
self.inferred
.entry(fragment.sym.clone())
.or_insert(VueHelper::Fragment);
}
}
if matches!(
self.call_helper(call),
Some(VueHelper::CreateBlock | VueHelper::CreateVNode)
) {
self.infer_builtin_component_arg(call);
}
if matches!(self.call_helper(call), Some(VueHelper::RenderList)) {
if let Some(source) = call.args.first() {
self.infer_render_list_source_unref(source.expr.as_ref());
}
}
if matches!(
self.call_helper(call),
Some(
VueHelper::CreateBlock
| VueHelper::CreateElementBlock
| VueHelper::CreateElementVNode
| VueHelper::CreateVNode
)
) {
self.infer_render_prop_unrefs(call);
self.infer_render_child_helpers(call);
}
call.visit_children_with(self);
}
}
impl HelperInference<'_> {
fn call_helper(&self, call: &CallExpr) -> Option<VueHelper> {
call_callee_ident(call).and_then(|callee| {
self.inferred
.get(&callee.sym)
.or_else(|| {
self.import_resolves(callee)
.then(|| self.known_helpers.get(&callee.sym))
.flatten()
})
.cloned()
})
}
fn fragment_block_call<'a>(
&self,
call: &'a CallExpr,
) -> Option<(
&'a swc_core::ecma::ast::Ident,
Option<&'a swc_core::ecma::ast::Ident>,
)> {
let callee = call_callee_ident(call)?;
if !self.is_candidate(callee) {
return None;
}
if !is_fragment_patch_flag(call.args.get(3).map(|arg| arg.expr.as_ref())) {
return None;
}
let fragment = call
.args
.first()
.and_then(|arg| ident_expr(arg.expr.as_ref()))?;
if self.is_candidate(fragment) || self.import_resolves(fragment) {
return Some((callee, Some(fragment)));
}
if self.is_unresolved_fragment_name(fragment) {
return Some((callee, None));
}
None
}
fn is_unresolved_fragment_name(&self, ident: &Ident) -> bool {
ident.sym.as_ref() == "Fragment" && ident.ctxt == self.unresolved_ctxt
}
fn with_directives_call<'a>(
&self,
call: &'a CallExpr,
) -> Option<&'a swc_core::ecma::ast::Ident> {
let callee = call_callee_ident(call)?;
if !is_with_directives_call(&call.args) {
return None;
}
let base = call.args.first()?;
self.is_likely_vnode_expr(base.expr.as_ref())
.then_some(callee)
}
fn is_likely_vnode_expr(&self, expr: &Expr) -> bool {
match unwrap_paren_expr(expr) {
Expr::Seq(seq) => seq
.exprs
.last()
.is_some_and(|expr| self.is_likely_vnode_expr(expr.as_ref())),
Expr::Call(call) => self
.call_helper(call)
.or_else(|| infer_call_helper(call))
.is_some_and(|helper| {
matches!(
helper,
VueHelper::CreateBlock
| VueHelper::CreateElementBlock
| VueHelper::CreateElementVNode
| VueHelper::CreateVNode
)
}),
_ => false,
}
}
fn infer_unref_expr(&mut self, expr: &Expr) {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return;
};
if !is_display_string_call(&call.args) {
return;
}
let Some(callee) = call_callee_ident(call) else {
return;
};
if !self.is_candidate(callee) {
return;
}
self.inferred.insert(callee.sym.clone(), VueHelper::Unref);
}
fn infer_condition_unref_expr(&mut self, expr: &Expr) {
match unwrap_paren_expr(expr) {
Expr::Call(_) => self.infer_unref_expr(expr),
Expr::Unary(unary) if unary.op == UnaryOp::Bang => {
self.infer_condition_unref_expr(unary.arg.as_ref());
}
Expr::Bin(bin)
if matches!(
bin.op,
BinaryOp::LogicalAnd
| BinaryOp::LogicalOr
| BinaryOp::EqEq
| BinaryOp::EqEqEq
| BinaryOp::NotEq
| BinaryOp::NotEqEq
) =>
{
self.infer_condition_unref_expr(bin.left.as_ref());
self.infer_condition_unref_expr(bin.right.as_ref());
}
Expr::Cond(cond) => {
self.infer_condition_unref_expr(cond.test.as_ref());
}
_ => {}
}
}
fn infer_render_prop_unrefs(&mut self, call: &CallExpr) {
let Some(props) = call.args.get(1).and_then(|arg| match arg.expr.as_ref() {
Expr::Object(object) => Some(object),
_ => None,
}) else {
return;
};
self.prop_value_depth += 1;
for prop in &props.props {
match prop {
PropOrSpread::Prop(prop) => {
if let Prop::KeyValue(key_value) = prop.as_ref() {
key_value.value.visit_with(self);
}
}
PropOrSpread::Spread(spread) => {
spread.expr.visit_with(self);
}
}
}
self.prop_value_depth -= 1;
}
fn infer_render_prop_unref_call(&mut self, call: &CallExpr) {
if !is_render_prop_unref_call(&call.args) {
return;
}
let Some(callee) = call_callee_ident(call) else {
return;
};
if !self.is_candidate(callee) {
return;
}
self.inferred.insert(callee.sym.clone(), VueHelper::Unref);
}
fn infer_render_child_helpers(&mut self, call: &CallExpr) {
let Some(children) = call.args.get(2) else {
return;
};
self.vnode_child_depth += 1;
children.expr.visit_with(self);
self.vnode_child_depth -= 1;
}
fn infer_vnode_child_helper_call(&mut self, call: &CallExpr) {
if !is_static_text_vnode_call(&call.args) {
return;
}
let Some(callee) = call_callee_ident(call) else {
return;
};
if !self.is_candidate(callee) {
return;
}
self.inferred
.entry(callee.sym.clone())
.or_insert(VueHelper::CreateTextVNode);
}
fn infer_render_list_source_unref(&mut self, expr: &Expr) {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return;
};
self.infer_render_prop_unref_call(call);
}
fn infer_builtin_component_arg(&mut self, call: &CallExpr) {
let Some(component) = call
.args
.first()
.and_then(|arg| ident_expr(arg.expr.as_ref()))
.filter(|&ident| self.is_candidate(ident))
else {
return;
};
let Some(props) = call.args.get(1).and_then(|arg| match arg.expr.as_ref() {
Expr::Object(object) => Some(object),
_ => None,
}) else {
return;
};
if is_transition_component_props(props) {
self.inferred
.entry(component.sym.clone())
.or_insert(VueHelper::Other("Transition".to_string()));
}
}
}
fn is_render_prop_unref_call(args: &[ExprOrSpread]) -> bool {
if args.len() != 1 {
return false;
}
matches!(
args.first().map(|arg| unwrap_paren_expr(arg.expr.as_ref())),
Some(Expr::Ident(_) | Expr::Member(_) | Expr::OptChain(_))
)
}
fn is_transition_component_props(object: &ObjectLit) -> bool {
object.props.iter().any(|prop| {
let PropOrSpread::Prop(prop) = prop else {
return false;
};
let Prop::KeyValue(key_value) = prop.as_ref() else {
return false;
};
matches!(
prop_name(&key_value.key).as_deref(),
Some(
"onBeforeEnter"
| "onEnter"
| "onAfterEnter"
| "onEnterCancelled"
| "onBeforeLeave"
| "onLeave"
| "onAfterLeave"
| "onLeaveCancelled"
)
)
})
}
fn is_fragment_patch_flag(expr: Option<&Expr>) -> bool {
matches!(
expr,
Some(Expr::Lit(Lit::Num(number)))
if matches!(number.value as i32, 64 | 128 | 256)
)
}
pub(super) fn unwrap_paren_expr(expr: &Expr) -> &Expr {
match expr {
Expr::Paren(paren) => unwrap_paren_expr(paren.expr.as_ref()),
_ => expr,
}
}
fn infer_call_helper(call: &CallExpr) -> Option<VueHelper> {
if is_with_directives_call(&call.args) {
return Some(VueHelper::WithDirectives);
}
if is_with_memo_call(&call.args) {
return Some(VueHelper::WithMemo);
}
if is_create_slots_call(&call.args) {
return Some(VueHelper::CreateSlots);
}
if is_render_slot_call(&call.args) {
return Some(VueHelper::RenderSlot);
}
if is_render_list_call(&call.args) {
return Some(VueHelper::RenderList);
}
if is_event_modifier_helper_call(&call.args) {
return Some(VueHelper::WithModifiers);
}
if is_with_ctx_call(&call.args) {
return Some(VueHelper::WithCtx);
}
if is_create_static_vnode_call(&call.args) {
return Some(VueHelper::CreateStaticVNode);
}
if is_create_comment_vnode_call(&call.args) {
return Some(VueHelper::CreateCommentVNode);
}
if is_create_text_vnode_call(&call.args) {
return Some(VueHelper::CreateTextVNode);
}
if is_element_vnode_call(&call.args) {
return Some(VueHelper::CreateElementBlock);
}
if is_component_vnode_call(&call.args) {
return Some(VueHelper::CreateVNode);
}
if is_resolve_component_call(&call.args) {
return Some(VueHelper::ResolveComponent);
}
if is_display_string_call(&call.args) {
return Some(VueHelper::ToDisplayString);
}
if is_open_block_call(&call.args) {
return Some(VueHelper::OpenBlock);
}
None
}
fn is_with_directives_call(args: &[ExprOrSpread]) -> bool {
matches!(args.get(1).map(|arg| arg.expr.as_ref()), Some(Expr::Array(array)) if array.elems.iter().flatten().any(|elem| matches!(elem.expr.as_ref(), Expr::Array(_))))
}
fn is_with_memo_call(args: &[ExprOrSpread]) -> bool {
args.len() >= 4
&& matches!(
args.get(1).map(|arg| arg.expr.as_ref()),
Some(Expr::Arrow(_))
)
}
fn is_create_slots_call(args: &[ExprOrSpread]) -> bool {
matches!(
args.first().map(|arg| arg.expr.as_ref()),
Some(Expr::Object(_))
) && matches!(
args.get(1).map(|arg| arg.expr.as_ref()),
Some(Expr::Array(_))
)
}
fn is_render_slot_call(args: &[ExprOrSpread]) -> bool {
args.len() >= 2
&& args
.first()
.is_some_and(|arg| is_slots_source_expr(arg.expr.as_ref()))
}
fn is_slots_source_expr(expr: &Expr) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => matches!(ident.sym.as_ref(), "$slots" | "slots"),
Expr::Member(member) => is_slots_member_prop(&member.prop),
_ => false,
}
}
fn is_slots_member_prop(prop: &MemberProp) -> bool {
match prop {
MemberProp::Ident(ident) => ident.sym.as_ref() == "$slots",
MemberProp::Computed(computed) => {
string_lit(computed.expr.as_ref()).as_deref() == Some("$slots")
}
MemberProp::PrivateName(_) => false,
}
}
fn is_setup_slots_member_prop(prop: &MemberProp) -> bool {
match prop {
MemberProp::Ident(ident) => matches!(ident.sym.as_ref(), "$slots" | "slots"),
MemberProp::Computed(computed) => {
matches!(
string_lit(computed.expr.as_ref()).as_deref(),
Some("$slots" | "slots")
)
}
MemberProp::PrivateName(_) => false,
}
}
fn is_render_list_call(args: &[ExprOrSpread]) -> bool {
matches!(
args.get(1).map(|arg| arg.expr.as_ref()),
Some(Expr::Arrow(_))
)
}
fn is_event_modifier_helper_call(args: &[ExprOrSpread]) -> bool {
if args.len() != 2 {
return false;
}
let Some(modifiers) = args.get(1).and_then(|arg| match arg.expr.as_ref() {
Expr::Array(array) => Some(array),
_ => None,
}) else {
return false;
};
if modifiers
.elems
.iter()
.flatten()
.any(|elem| string_lit(elem.expr.as_ref()).is_none())
{
return false;
}
matches!(
args.first().map(|arg| unwrap_paren_expr(arg.expr.as_ref())),
Some(
Expr::Ident(_)
| Expr::Member(_)
| Expr::Call(_)
| Expr::Arrow(_)
| Expr::Fn(_)
| Expr::Bin(_)
| Expr::Assign(_)
)
)
}
fn is_with_ctx_call(args: &[ExprOrSpread]) -> bool {
matches!(
args.first().map(|arg| arg.expr.as_ref()),
Some(Expr::Arrow(_))
)
}
fn is_create_static_vnode_call(args: &[ExprOrSpread]) -> bool {
args.first()
.and_then(|arg| string_lit(arg.expr.as_ref()))
.is_some_and(|value| value.contains('<'))
}
fn is_create_comment_vnode_call(args: &[ExprOrSpread]) -> bool {
args.first()
.is_some_and(|arg| string_lit(arg.expr.as_ref()).is_some())
&& matches!(
args.get(1).map(|arg| arg.expr.as_ref()),
Some(Expr::Lit(Lit::Bool(_)))
)
}
fn is_create_text_vnode_call(args: &[ExprOrSpread]) -> bool {
args.get(1)
.is_some_and(|arg| is_numeric_expr(arg.expr.as_ref()))
}
fn is_static_text_vnode_call(args: &[ExprOrSpread]) -> bool {
matches!(args.len(), 1 | 2)
&& args
.first()
.is_some_and(|arg| string_lit(arg.expr.as_ref()).is_some())
&& args
.get(1)
.is_none_or(|arg| is_numeric_expr(arg.expr.as_ref()))
}
fn is_numeric_expr(expr: &Expr) -> bool {
match unwrap_paren_expr(expr) {
Expr::Lit(Lit::Num(_)) => true,
Expr::Unary(unary) if unary.op == UnaryOp::Minus => {
matches!(
unwrap_paren_expr(unary.arg.as_ref()),
Expr::Lit(Lit::Num(_))
)
}
_ => false,
}
}
fn is_element_vnode_call(args: &[ExprOrSpread]) -> bool {
args.len() >= 2
&& args
.first()
.and_then(|arg| string_lit(arg.expr.as_ref()))
.is_some_and(|value| !value.contains('<'))
}
fn is_component_vnode_call(args: &[ExprOrSpread]) -> bool {
args.len() >= 2
&& !matches!(
args.first().map(|arg| arg.expr.as_ref()),
Some(Expr::Lit(Lit::Str(_)) | Expr::Object(_))
)
}
fn is_resolve_component_call(args: &[ExprOrSpread]) -> bool {
args.len() == 1
&& args
.first()
.is_some_and(|arg| string_lit(arg.expr.as_ref()).is_some())
}
fn is_display_string_call(args: &[ExprOrSpread]) -> bool {
args.len() == 1
&& args
.first()
.is_none_or(|arg| string_lit(arg.expr.as_ref()).is_none())
}
fn is_open_block_call(args: &[ExprOrSpread]) -> bool {
args.is_empty()
|| matches!(
args.first().map(|arg| arg.expr.as_ref()),
Some(Expr::Lit(Lit::Bool(_)))
)
}
pub(super) fn call_callee_ident(call: &CallExpr) -> Option<&swc_core::ecma::ast::Ident> {
let Callee::Expr(callee) = &call.callee else {
return None;
};
ident_expr(callee.as_ref())
}
fn ident_expr(expr: &Expr) -> Option<&swc_core::ecma::ast::Ident> {
match expr {
Expr::Ident(ident) => Some(ident),
_ => None,
}
}
pub(super) fn collect_render_context(render: RenderSource<'_>, ctx: &mut VueRecoveryContext) {
let Some(stmts) = render_stmts(render) else {
return;
};
let mut slot_partition_bindings = HashSet::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for decl in &var.decls {
let Some(init) = decl.init.as_deref() else {
continue;
};
match &decl.name {
Pat::Ident(binding) => {
if let Some(component) = resolve_component_name(init, ctx) {
ctx.component_bindings
.insert(binding.id.sym.clone(), component);
}
if let Some(directive) = resolve_directive_name(init, ctx) {
ctx.directive_bindings
.insert(binding.id.sym.clone(), directive);
}
if is_slot_partition_expr(init, ctx) {
slot_partition_bindings.insert(binding.id.sym.clone());
}
if is_slot_partition_slots_alias(init, &slot_partition_bindings) {
ctx.slot_bindings.insert(binding.id.sym.clone());
}
if let Some(source) =
slot_partition_child_list_alias_source(init, &slot_partition_bindings)
{
insert_render_child_list_binding(ctx, binding.id.sym.clone(), source);
}
if let Some(slot) = render_slot_binding_expr(init, ctx) {
ctx.render_slot_bindings
.insert(binding.id.sym.clone(), slot);
}
}
Pat::Object(object)
if is_slot_partition_expr(init, ctx)
|| is_slot_partition_alias(init, &slot_partition_bindings) =>
{
collect_named_object_pat_bindings(object, "slots", &mut ctx.slot_bindings);
collect_slot_partition_child_list_bindings(object, ctx);
}
_ => {}
}
}
}
}
#[derive(Clone, Copy)]
enum SetupRenderNode<'a> {
Arrow(&'a ArrowExpr),
Function(&'a FnDecl),
}
fn visit_setup_render<V: Visit>(render: SetupRenderNode<'_>, visitor: &mut V) {
match render {
SetupRenderNode::Arrow(render) => render.visit_with(visitor),
SetupRenderNode::Function(render) => render.visit_with(visitor),
}
}
// Vue's playground compiles `<script setup>` with `inlineTemplate` in development.
// That shape has no `__isScriptSetup` marker, so use its generated component name
// together with the setup props and context/cache render parameters. Their names are
// not stable because downstream minifiers may rename them.
fn is_compiled_inline_script_setup(render: RenderSource<'_>) -> bool {
let RenderSource::SetupArrow {
render,
setup_props: Some(_),
component_options: Some(options),
..
} = render
else {
return false;
};
render.params.len() >= 2
&& options.props.iter().any(|prop| {
matches!(
prop,
PropOrSpread::Prop(prop)
if match prop.as_ref() {
Prop::KeyValue(key_value) => {
prop_name(&key_value.key).as_deref() == Some("__name")
}
_ => false,
}
)
})
}
pub(super) fn collect_setup_context(
render: RenderSource<'_>,
compiled_setup: Option<CompiledScriptSetup<'_>>,
ctx: &mut VueRecoveryContext,
) -> Result<()> {
let owned_setup_stmts: Vec<Stmt>;
let preserve_inline_script_setup = is_compiled_inline_script_setup(render);
let (render, setup_stmts, setup_slots, setup_expose, preserve_side_effects) = match render {
RenderSource::SetupArrow {
render,
setup_stmts,
setup_slots,
..
} => (
SetupRenderNode::Arrow(render),
setup_stmts,
setup_slots.map(|slots| slots.sym.clone()),
None,
preserve_inline_script_setup,
),
RenderSource::Function { render, .. } => {
let Some(setup) = compiled_setup else {
return Ok(());
};
owned_setup_stmts = setup.setup_stmts.to_vec();
(
SetupRenderNode::Function(render),
owned_setup_stmts.as_slice(),
setup.setup_slots.map(|slots| slots.sym.clone()),
setup
.setup_expose
.map(|expose| (expose.sym.clone(), expose.ctxt)),
true,
)
}
};
if let Some(setup_slots) = setup_slots {
ctx.slot_bindings.insert(setup_slots);
}
let setup_tuple_value_candidates = setup_tuple_value_candidates(setup_stmts);
let setup_template_ref_refs =
setup_render_template_ref_refs(render, setup_stmts, ctx, &setup_tuple_value_candidates);
let setup_template_ref_aliases = setup_render_template_ref_aliases(render);
let setup_template_ref_alias_sources = setup_template_ref_aliases
.iter()
.map(|(from, _, _)| from.clone())
.collect::<HashSet<_>>();
let setup_ref_object_alias_refs = setup_ref_object_alias_refs(setup_stmts);
let setup_non_value_member_refs = setup_non_value_member_refs(setup_stmts);
let setup_value_member_refs = setup_value_member_refs(render, setup_stmts);
let setup_render_refs = render_ident_refs(render);
let compiled_return_binding = preserve_side_effects
.then(|| compiled_setup_return_binding(setup_stmts))
.flatten();
let compiled_return_values = compiled_return_binding
.as_ref()
.map(|binding| compiled_setup_return_values(setup_stmts, binding))
.unwrap_or_default();
let mut provider_ref_object_bindings = HashMap::new();
let mut composable_ref_object_bindings = HashMap::new();
let mut local_candidates = Vec::new();
for (setup_order, stmt) in setup_stmts.iter().enumerate() {
match stmt {
Stmt::Decl(Decl::Fn(function)) => {
local_candidates.push(SetupLocalCandidate {
bindings: vec![function.ident.sym.clone()],
stmt: stmt.clone(),
template_selectable: true,
setup_order,
always_emit: preserve_side_effects,
preserve_ref_values: preserve_side_effects,
});
}
Stmt::Decl(Decl::Class(class)) => {
local_candidates.push(SetupLocalCandidate {
bindings: vec![class.ident.sym.clone()],
stmt: stmt.clone(),
template_selectable: true,
setup_order,
always_emit: preserve_side_effects,
preserve_ref_values: preserve_side_effects,
});
}
Stmt::Decl(Decl::Var(var)) => {
let mut local_decls = Vec::new();
let mut local_bindings = HashSet::new();
for original_decl in &var.decls {
let rewritten_decl = match (&original_decl.name, original_decl.init.as_deref())
{
(Pat::Ident(binding), Some(init)) if is_undefined_placeholder(init) => {
compiled_return_values
.iter()
.find(|(name, _, _)| name == &binding.id.sym)
.map(|(_, init, _)| {
let mut decl = original_decl.clone();
decl.init = Some(init.clone());
decl
})
}
_ => None,
};
let decl = rewritten_decl.as_ref().unwrap_or(original_decl);
if matches!(
(&decl.name, compiled_return_binding.as_ref()),
(Pat::Ident(binding), Some((name, ctxt)))
if binding.id.sym == *name && binding.id.ctxt == *ctxt
) {
continue;
}
let consumed = match decl.init.as_deref() {
Some(init) => match &decl.name {
Pat::Ident(binding) => {
if record_compiled_setup_alias(
&binding.id.sym,
Some(binding.id.ctxt),
init,
ctx,
) {
true
} else if preserve_side_effects {
if is_ref_like_value_expr(init, ctx) {
ctx.bindings.refs.insert(binding.id.sym.clone());
}
false
} else if let Some(alias) = ident_expr(unwrap_paren_expr(init)) {
ctx.bindings
.aliases
.insert(binding.id.sym.clone(), alias.sym.clone());
ctx.bindings
.alias_ctxts
.insert(binding.id.sym.clone(), binding.id.ctxt);
true
} else {
if let Some(ref_props) =
setup_ref_props(init, ctx, &provider_ref_object_bindings)
{
provider_ref_object_bindings
.insert(binding.id.sym.clone(), ref_props);
}
if let Some(ref_props) = setup_composable_ref_props(
init,
ctx,
&composable_ref_object_bindings,
) {
composable_ref_object_bindings
.insert(binding.id.sym.clone(), ref_props);
}
let is_ref_object = is_ref_object_expr(init, ctx);
if is_ref_object {
ctx.bindings.ref_objects.insert(binding.id.sym.clone());
}
let is_ref_object_alias_source = is_ref_object
&& setup_ref_object_alias_refs.contains(&binding.id.sym);
if setup_value_member_refs
.contains(&(binding.id.sym.clone(), binding.id.ctxt))
&& is_ref_member_extraction_expr(
init,
ctx,
&provider_ref_object_bindings,
)
{
ctx.bindings.refs.insert(binding.id.sym.clone());
if is_composable_ref_member_extraction_expr(
init,
ctx,
&composable_ref_object_bindings,
) {
ctx.bindings
.composable_refs
.insert(binding.id.sym.clone());
}
}
if let Some(value) = computed_value_expr(init, ctx)? {
if setup_value_member_refs
.contains(&(binding.id.sym.clone(), binding.id.ctxt))
{
collect_setup_value_template_tuple_refs(
&value,
&setup_tuple_value_candidates,
ctx,
);
}
ctx.bindings.values.insert(binding.id.sym.clone(), value);
let mut local_var = var.as_ref().clone();
local_var.decls = vec![decl.clone()];
local_candidates.push(SetupLocalCandidate {
bindings: vec![binding.id.sym.clone()],
stmt: Stmt::Decl(Decl::Var(Box::new(local_var))),
template_selectable: false,
setup_order,
always_emit: false,
preserve_ref_values: preserve_side_effects,
});
true
} else if let Some((value, import_refs)) =
computed_script_setup_expr(init, ctx)?
{
ctx.setup_script_import_refs.extend(import_refs);
ctx.setup_script_bindings.push(VueSetupScriptBinding {
binding: binding.id.sym.clone(),
value,
setup_order,
});
ctx.bindings.refs.insert(binding.id.sym.clone());
true
} else if (!is_ref_object_alias_source
|| setup_template_ref_alias_sources
.contains(&binding.id.sym))
&& !setup_non_value_member_refs
.contains(&(binding.id.sym.clone(), binding.id.ctxt))
&& (setup_template_ref_alias_sources
.contains(&binding.id.sym)
|| should_emit_ref_script_setup_expr(
init,
ctx,
&binding.id,
&setup_value_member_refs,
))
{
if let Some((expr, helper, known_ref)) =
ref_script_setup_expr(init, ctx)?
{
ctx.setup_ref_script_bindings.push(
VueSetupRefBinding {
binding: binding.id.sym.clone(),
expr,
helper,
known_ref,
},
);
}
ctx.bindings.refs.insert(binding.id.sym.clone());
true
} else {
false
}
}
}
Pat::Object(object) if is_setup_context_alias(init, ctx) => {
collect_named_object_pat_bindings(
object,
"slots",
&mut ctx.slot_bindings,
);
false
}
Pat::Object(_) if is_setup_props_alias(init, ctx) => true,
Pat::Object(object)
if is_ref_object_expr(init, ctx)
|| is_ref_object_alias(init, ctx) =>
{
collect_object_pat_bindings(object, &mut ctx.bindings.refs);
false
}
Pat::Object(object) => {
if let Some(ref_props) =
setup_ref_props(init, ctx, &provider_ref_object_bindings)
{
collect_provider_object_pat_bindings(
object,
&ref_props,
&mut ctx.bindings.refs,
);
}
if let Some(ref_props) = setup_composable_ref_props(
init,
ctx,
&composable_ref_object_bindings,
) {
collect_provider_object_pat_bindings(
object,
&ref_props,
&mut ctx.bindings.composable_refs,
);
}
false
}
_ => false,
},
None => false,
};
if consumed {
continue;
}
let mut decl_bindings = HashSet::new();
collect_pat_bindings(&decl.name, &mut decl_bindings);
if decl_bindings.is_empty() {
continue;
}
let has_template_ref = decl_bindings
.iter()
.any(|binding| setup_template_ref_refs.contains(binding));
let has_render_ref = decl_bindings
.iter()
.any(|binding| setup_render_refs.contains(binding));
let is_ref_object_local = decl.init.as_deref().is_some_and(|init| {
is_ref_object_expr(init, ctx) || is_ref_object_alias(init, ctx)
});
let is_imported_call_local = decl
.init
.as_deref()
.is_some_and(|init| is_script_import_call_expr(init, ctx));
let is_provider_ref_local = decl.init.as_deref().is_some_and(|init| {
setup_ref_props(init, ctx, &provider_ref_object_bindings).is_some()
});
let is_local_candidate = match &decl.name {
Pat::Ident(_) | Pat::Array(_) => true,
Pat::Object(_) => {
preserve_side_effects
|| has_template_ref
|| has_render_ref
|| is_ref_object_local
|| is_imported_call_local
|| is_provider_ref_local
}
_ => false,
};
if !is_local_candidate {
continue;
}
if has_template_ref && matches!(decl.name, Pat::Object(_)) {
ctx.bindings
.template_refs
.extend(decl_bindings.iter().cloned());
} else {
ctx.bindings.template_refs.extend(
decl_bindings
.iter()
.filter(|binding| setup_template_ref_refs.contains(*binding))
.cloned(),
);
}
local_bindings.extend(decl_bindings);
local_decls.push(decl.clone());
}
if !local_decls.is_empty() {
let mut bindings = local_bindings.into_iter().collect::<Vec<_>>();
bindings.sort_by(|left, right| left.as_ref().cmp(right.as_ref()));
bindings.dedup();
let mut local_var = var.as_ref().clone();
local_var.decls = local_decls;
local_candidates.push(SetupLocalCandidate {
bindings,
stmt: Stmt::Decl(Decl::Var(Box::new(local_var))),
template_selectable: true,
setup_order,
always_emit: preserve_side_effects,
preserve_ref_values: preserve_side_effects,
});
}
}
_ if preserve_side_effects
&& !matches!(stmt, Stmt::Empty(_) | Stmt::Return(_))
&& !is_compiled_setup_artifact_stmt(stmt, setup_expose.as_ref()) =>
{
local_candidates.push(SetupLocalCandidate {
bindings: Vec::new(),
stmt: stmt.clone(),
template_selectable: false,
setup_order,
always_emit: true,
preserve_ref_values: true,
});
}
_ => {}
}
}
let mut candidate_bindings = local_candidates
.iter()
.flat_map(|candidate| candidate.bindings.iter().cloned())
.collect::<HashSet<_>>();
for (binding, init, setup_order) in compiled_return_values {
if record_compiled_setup_alias(&binding, None, init.as_ref(), ctx) {
continue;
}
if candidate_bindings.contains(&binding)
|| ctx.top_level_binding_ctxts.contains_key(&binding)
{
continue;
}
if is_ref_like_value_expr(init.as_ref(), ctx) {
ctx.bindings.refs.insert(binding.clone());
}
let stmt = Stmt::Decl(Decl::Var(Box::new(VarDecl {
span: DUMMY_SP,
ctxt: Default::default(),
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(swc_core::ecma::ast::BindingIdent {
id: Ident::new(binding.clone(), DUMMY_SP, Default::default()),
type_ann: None,
}),
init: Some(init),
definite: false,
}],
})));
local_candidates.push(SetupLocalCandidate {
bindings: vec![binding.clone()],
stmt,
template_selectable: true,
setup_order,
always_emit: true,
preserve_ref_values: true,
});
candidate_bindings.insert(binding);
}
for (from, from_ctxt, to) in setup_template_ref_aliases {
if ctx
.setup_ref_script_bindings
.iter()
.any(|binding| binding.binding == from)
{
ctx.bindings.alias_ctxts.insert(from.clone(), from_ctxt);
ctx.bindings.aliases.insert(from, to);
}
}
refresh_setup_value_binding_sources(ctx)?;
assign_setup_prop_bindings(ctx, &local_candidates);
for candidate in local_candidates {
let cleaned_stmt = if candidate.preserve_ref_values {
clean_setup_stmt_preserving_ref_values(&candidate.stmt, ctx)
} else {
clean_setup_stmt(&candidate.stmt, ctx)
};
let source = print_clean_setup_stmt(&cleaned_stmt, ctx)?;
if !source.is_empty() {
let emitted_bindings = emitted_stmt_bindings(&source, ctx, &candidate.bindings);
ctx.setup_local_bindings.push(VueSetupLocalBinding {
bindings: candidate.bindings,
emitted_bindings,
refs: stmt_ident_refs(&cleaned_stmt),
source,
import_refs: stmt_import_refs(&cleaned_stmt, &ctx.script_imports),
stmt: cleaned_stmt,
module_scope: false,
template_selectable: candidate.template_selectable,
setup_order: candidate.setup_order,
always_emit: candidate.always_emit,
preserve_ref_values: candidate.preserve_ref_values,
});
}
}
Ok(())
}
fn setup_ref_object_alias_refs(stmts: &[Stmt]) -> HashSet<Atom> {
let mut refs = HashSet::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for decl in &var.decls {
if !matches!(decl.name, Pat::Object(_)) {
continue;
}
let Some(init) = decl.init.as_deref() else {
continue;
};
if let Some(ident) = ident_expr(unwrap_paren_expr(init)) {
refs.insert(ident.sym.clone());
}
}
}
refs
}
fn setup_non_value_member_refs(stmts: &[Stmt]) -> HashSet<(Atom, SyntaxContext)> {
let mut collector = NonValueMemberRefCollector {
refs: HashSet::new(),
};
for stmt in stmts {
stmt.visit_with(&mut collector);
}
collector.refs
}
fn setup_value_member_refs(
render: SetupRenderNode<'_>,
setup_stmts: &[Stmt],
) -> HashSet<(Atom, SyntaxContext)> {
let mut collector = ValueMemberIdentRefCollector {
refs: HashSet::new(),
};
for stmt in setup_stmts {
stmt.visit_with(&mut collector);
}
visit_setup_render(render, &mut collector);
collector.refs
}
/// Collects `(name, ctxt)` of every `<ident>.value` member base. Runs on the
/// pristine resolver-processed render/setup AST, so shadow safety comes from
/// `SyntaxContext` identity — a nested local reusing a setup binding's name
/// carries a different context and never matches the recorded binding. No
/// hand-rolled scope tracking is needed.
struct ValueMemberIdentRefCollector {
refs: HashSet<(Atom, SyntaxContext)>,
}
impl Visit for ValueMemberIdentRefCollector {
fn visit_member_expr(&mut self, member: &MemberExpr) {
if matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "value") {
if let Expr::Ident(object) = member.obj.as_ref() {
self.refs.insert((object.sym.clone(), object.ctxt));
}
}
member.visit_children_with(self);
}
}
/// Collects `(name, ctxt)` of every non-`.value` member base
/// (`<ident>.<prop>`). Ctxt-keyed for the same reason as
/// [`ValueMemberIdentRefCollector`].
struct NonValueMemberRefCollector {
refs: HashSet<(Atom, SyntaxContext)>,
}
impl Visit for NonValueMemberRefCollector {
fn visit_member_expr(&mut self, member: &MemberExpr) {
if !matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "value") {
if let Expr::Ident(object) = member.obj.as_ref() {
self.refs.insert((object.sym.clone(), object.ctxt));
}
}
member.visit_children_with(self);
}
}
fn setup_render_template_ref_aliases(
render: SetupRenderNode<'_>,
) -> Vec<(Atom, SyntaxContext, Atom)> {
let mut collector = TemplateRefAliasCollector {
aliases: Vec::new(),
};
visit_setup_render(render, &mut collector);
collector.aliases
}
struct TemplateRefAliasCollector {
aliases: Vec<(Atom, SyntaxContext, Atom)>,
}
impl Visit for TemplateRefAliasCollector {
fn visit_object_lit(&mut self, object: &ObjectLit) {
let mut ref_key = None;
let mut ref_binding = None;
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
continue;
};
let Prop::KeyValue(key_value) = prop.as_ref() else {
continue;
};
match prop_name(&key_value.key).as_deref() {
Some("ref_key") => {
ref_key = string_lit(key_value.value.as_ref())
.filter(|name| is_valid_identifier_name(name))
.map(Atom::from);
}
Some("ref") => {
if let Expr::Ident(ident) = unwrap_paren_expr(key_value.value.as_ref()) {
ref_binding = Some((ident.sym.clone(), ident.ctxt));
}
}
_ => {}
}
}
if let (Some((from, from_ctxt)), Some(to)) = (ref_binding, ref_key) {
self.aliases.push((from, from_ctxt, to));
}
object.visit_children_with(self);
}
}
fn render_ident_refs(render: SetupRenderNode<'_>) -> HashSet<Atom> {
let mut declared_collector = DeclaredBindingIdents {
idents: HashSet::new(),
};
visit_setup_render(render, &mut declared_collector);
let declared = declared_collector.idents;
let mut collector = IdentRefCollector {
declared: &declared,
refs: HashSet::new(),
};
visit_setup_render(render, &mut collector);
collector.refs
}
fn setup_tuple_value_candidates(setup_stmts: &[Stmt]) -> HashSet<(Atom, SyntaxContext)> {
let mut tuple_value_candidates = HashSet::new();
for stmt in setup_stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for decl in &var.decls {
let Some(init) = decl.init.as_deref() else {
continue;
};
match &decl.name {
Pat::Array(_) => {
collect_pat_binding_idents(&decl.name, &mut tuple_value_candidates)
}
Pat::Ident(binding) if is_tuple_element_expr(init) => {
tuple_value_candidates.insert((binding.id.sym.clone(), binding.id.ctxt));
}
_ => {}
}
}
}
tuple_value_candidates
}
fn setup_render_template_ref_refs(
render: SetupRenderNode<'_>,
setup_stmts: &[Stmt],
ctx: &VueRecoveryContext,
tuple_value_candidates: &HashSet<(Atom, SyntaxContext)>,
) -> HashSet<Atom> {
let mut object_value_candidates = HashSet::new();
let mut unref_candidates = HashSet::new();
for stmt in setup_stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for decl in &var.decls {
let Some(_init) = decl.init.as_deref() else {
continue;
};
if matches!(decl.name, Pat::Object(_)) {
collect_pat_binding_idents(&decl.name, &mut object_value_candidates);
collect_pat_binding_idents(&decl.name, &mut unref_candidates);
}
}
}
if tuple_value_candidates.is_empty()
&& (object_value_candidates.is_empty() || unref_candidates.is_empty())
{
return HashSet::new();
}
let mut collector = RenderTemplateRefCollector {
tuple_value_candidates,
object_value_candidates: &object_value_candidates,
unref_candidates: &unref_candidates,
ctx,
tuple_value_refs: HashSet::new(),
object_value_refs: HashSet::new(),
unref_refs: HashSet::new(),
};
visit_setup_render(render, &mut collector);
let mut refs = collector.tuple_value_refs;
refs.extend(
collector
.object_value_refs
.intersection(&collector.unref_refs)
.cloned(),
);
refs
}
fn collect_setup_value_template_tuple_refs(
value: &VueSetupValueBinding,
tuple_value_candidates: &HashSet<(Atom, SyntaxContext)>,
ctx: &mut VueRecoveryContext,
) {
if tuple_value_candidates.is_empty() {
return;
}
let Some(expr) = value.expr.as_ref() else {
return;
};
for ref_ident in value_member_refs_in_expr(expr) {
if tuple_value_candidates.contains(&ref_ident) {
ctx.bindings.template_refs.insert(ref_ident.0);
}
}
}
fn value_member_refs_in_expr(expr: &Expr) -> HashSet<(Atom, SyntaxContext)> {
let mut collector = ValueMemberIdentRefCollector {
refs: HashSet::new(),
};
expr.visit_with(&mut collector);
collector.refs
}
struct RenderTemplateRefCollector<'a> {
tuple_value_candidates: &'a HashSet<(Atom, SyntaxContext)>,
object_value_candidates: &'a HashSet<(Atom, SyntaxContext)>,
unref_candidates: &'a HashSet<(Atom, SyntaxContext)>,
ctx: &'a VueRecoveryContext,
tuple_value_refs: HashSet<Atom>,
object_value_refs: HashSet<Atom>,
unref_refs: HashSet<Atom>,
}
impl RenderTemplateRefCollector<'_> {
fn collect_value_member(&mut self, member: &MemberExpr) {
if !matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "value") {
return;
}
let Expr::Ident(object) = member.obj.as_ref() else {
return;
};
// Candidate sets are keyed on the setup binding's `(name, ctxt)`, so a
// nested local reusing the name carries a different context and never
// matches — no scope stack required.
let key = (object.sym.clone(), object.ctxt);
if self.tuple_value_candidates.contains(&key) {
self.tuple_value_refs.insert(object.sym.clone());
}
if self.object_value_candidates.contains(&key) {
self.object_value_refs.insert(object.sym.clone());
}
}
fn collect_unref_call(&mut self, call: &CallExpr) {
if helper_name(&call.callee, self.ctx) != Some(VueHelper::Unref) {
return;
}
let Some(arg) = call.args.first() else {
return;
};
let Expr::Ident(object) = unwrap_paren_expr(arg.expr.as_ref()) else {
return;
};
if self
.unref_candidates
.contains(&(object.sym.clone(), object.ctxt))
{
self.unref_refs.insert(object.sym.clone());
}
}
}
impl Visit for RenderTemplateRefCollector<'_> {
fn visit_update_expr(&mut self, update: &UpdateExpr) {
if let Expr::Member(member) = update.arg.as_ref() {
self.collect_value_member(member);
}
update.visit_children_with(self);
}
fn visit_member_expr(&mut self, member: &MemberExpr) {
self.collect_value_member(member);
member.visit_children_with(self);
}
fn visit_call_expr(&mut self, call: &CallExpr) {
self.collect_unref_call(call);
call.visit_children_with(self);
}
fn visit_prop_name(&mut self, prop: &PropName) {
if let PropName::Computed(computed) = prop {
computed.visit_with(self);
}
}
fn visit_member_prop(&mut self, prop: &MemberProp) {
if let MemberProp::Computed(computed) = prop {
computed.visit_with(self);
}
}
}
fn is_tuple_element_expr(expr: &Expr) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
if !is_zero_member_prop(&member.prop) {
return false;
}
matches!(unwrap_paren_expr(member.obj.as_ref()), Expr::Call(_))
}
fn is_zero_member_prop(prop: &MemberProp) -> bool {
let MemberProp::Computed(computed) = prop else {
return false;
};
matches!(unwrap_paren_expr(computed.expr.as_ref()), Expr::Lit(Lit::Num(number)) if number.value == 0.0)
}
fn assign_setup_prop_bindings(
ctx: &mut VueRecoveryContext,
local_candidates: &[SetupLocalCandidate],
) {
ctx.bindings.props.clear();
let prop_names = ctx
.setup_component_options
.as_ref()
.or(ctx.component_options.as_ref())
.map(component_prop_names)
.unwrap_or_default();
let valid_props = prop_names
.into_iter()
.filter(|name| is_valid_identifier_name(name))
.map(Atom::from)
.collect::<Vec<_>>();
if valid_props.is_empty() {
return;
}
let mut reserved = HashSet::new();
reserved.extend(ctx.bindings.aliases.keys().cloned());
reserved.extend(
local_candidates
.iter()
.flat_map(|candidate| candidate.bindings.iter().cloned()),
);
reserved.extend(
ctx.setup_script_bindings
.iter()
.map(|binding| binding.binding.clone()),
);
reserved.extend(
ctx.setup_ref_script_bindings
.iter()
.map(|binding| binding.binding.clone()),
);
reserved.extend(ctx.setup_emit_aliases.iter().cloned());
if let Some(binding) = &ctx.setup_emit_context {
reserved.insert(binding.clone());
}
let mut used = reserved.clone();
used.extend(valid_props.iter().cloned());
for prop in valid_props {
let binding = if reserved.contains(&prop) {
unique_setup_prop_binding(&prop, &mut used)
} else {
used.insert(prop.clone());
prop.clone()
};
ctx.bindings.props.insert(prop, binding);
}
}
fn unique_setup_prop_binding(prop: &Atom, used: &mut HashSet<Atom>) -> Atom {
let mut index = 1;
loop {
let candidate = Atom::from(format!("{}_{index}", prop.as_ref()));
if used.insert(candidate.clone()) {
return candidate;
}
index += 1;
}
}
fn is_setup_props_alias(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Ident(ident) = unwrap_paren_expr(expr) else {
return false;
};
ctx.setup_props_context
.as_ref()
.is_some_and(|setup_props| setup_props == &ident.sym)
|| ctx.setup_props_aliases.contains(&ident.sym)
}
fn record_compiled_setup_alias(
binding: &Atom,
binding_ctxt: Option<SyntaxContext>,
expr: &Expr,
ctx: &mut VueRecoveryContext,
) -> bool {
if is_setup_props_alias(expr, ctx) {
ctx.setup_props_aliases.insert(binding.clone());
if let Some(ctxt) = binding_ctxt {
ctx.setup_props_alias_ctxts.insert(binding.clone(), ctxt);
}
return true;
}
if is_setup_emit_alias(expr, ctx) {
ctx.setup_emit_aliases.insert(binding.clone());
return true;
}
if is_setup_slot_alias(expr, ctx) {
ctx.slot_bindings.insert(binding.clone());
return true;
}
false
}
fn is_setup_emit_alias(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => {
ctx.setup_emit_context
.as_ref()
.is_some_and(|setup_emit| setup_emit == &ident.sym)
|| ctx.setup_emit_aliases.contains(&ident.sym)
}
Expr::Member(member) if matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "emit") =>
{
matches!(
member.obj.as_ref(),
Expr::Ident(object)
if ctx
.setup_context
.as_ref()
.is_some_and(|setup_context| setup_context == &object.sym)
)
}
_ => false,
}
}
fn is_setup_context_alias(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Ident(ident) = unwrap_paren_expr(expr) else {
return false;
};
ctx.setup_context
.as_ref()
.is_some_and(|setup_context| setup_context == &ident.sym)
}
fn is_setup_slot_alias(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => ctx.slot_bindings.contains(&ident.sym),
Expr::Member(member) if is_setup_slots_member_prop(&member.prop) => {
matches!(
member.obj.as_ref(),
Expr::Ident(object)
if ctx
.setup_context
.as_ref()
.is_some_and(|setup_context| setup_context == &object.sym)
)
}
_ => false,
}
}
fn is_slot_partition_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
call.args
.first()
.is_some_and(|arg| is_slot_source_expr(arg.expr.as_ref(), ctx))
}
fn is_slot_partition_slots_alias(expr: &Expr, slot_partition_bindings: &HashSet<Atom>) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
if !is_setup_slots_member_prop(&member.prop) {
return false;
}
matches!(
member.obj.as_ref(),
Expr::Ident(object) if slot_partition_bindings.contains(&object.sym)
)
}
fn slot_partition_child_list_alias_source(
expr: &Expr,
slot_partition_bindings: &HashSet<Atom>,
) -> Option<VueRenderChildListSource> {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return None;
};
if !member_prop_is_named(&member.prop, "slides") {
return None;
}
matches!(
member.obj.as_ref(),
Expr::Ident(object) if slot_partition_bindings.contains(&object.sym)
)
.then_some(VueRenderChildListSource::SlotPartitionChildren)
}
fn render_slot_binding_expr(expr: &Expr, ctx: &VueRecoveryContext) -> Option<VueRenderSlotBinding> {
match unwrap_paren_expr(expr) {
Expr::Call(call) => {
if let Some(binding) = slot_call_binding(call, ctx) {
return Some(binding);
}
if is_slot_call_wrapper(call, ctx) {
return render_slot_binding_expr(call.args[0].expr.as_ref(), ctx);
}
None
}
Expr::Bin(bin) if bin.op == BinaryOp::LogicalAnd && is_slot_member_expr(&bin.left, ctx) => {
render_slot_binding_expr(bin.right.as_ref(), ctx)
}
Expr::Seq(seq) => seq
.exprs
.last()
.and_then(|expr| render_slot_binding_expr(expr.as_ref(), ctx)),
Expr::Assign(assign) => render_slot_binding_expr(assign.right.as_ref(), ctx),
_ => None,
}
}
fn is_slot_call_wrapper(call: &CallExpr, ctx: &VueRecoveryContext) -> bool {
call.args.len() == 1
&& call.args[0].spread.is_none()
&& (helper_name(&call.callee, ctx).is_some()
|| call_callee_ident(call).is_some_and(|callee| {
(ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee))
|| ctx.slot_result_normalizers.contains(&callee.sym)
}))
}
fn is_slot_member_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
member_prop_name(&member.prop).is_some() && is_slot_source_expr(member.obj.as_ref(), ctx)
}
fn is_slot_partition_alias(expr: &Expr, slot_partition_bindings: &HashSet<Atom>) -> bool {
let Expr::Ident(ident) = unwrap_paren_expr(expr) else {
return false;
};
slot_partition_bindings.contains(&ident.sym)
}
fn is_slot_source_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
match unwrap_paren_expr(expr) {
Expr::Ident(ident) => {
matches!(ident.sym.as_ref(), "$slots" | "slots")
|| ctx.slot_bindings.contains(&ident.sym)
}
Expr::Member(member) if is_slots_member_prop(&member.prop) => true,
Expr::Member(member) if is_setup_slots_member_prop(&member.prop) => {
matches!(
member.obj.as_ref(),
Expr::Ident(object)
if ctx
.setup_context
.as_ref()
.is_some_and(|setup_context| setup_context == &object.sym)
)
}
_ => false,
}
}
fn collect_slot_partition_child_list_bindings(object: &ObjectPat, ctx: &mut VueRecoveryContext) {
let mut bindings = HashSet::new();
collect_named_object_pat_bindings(object, "slides", &mut bindings);
for binding in bindings {
insert_render_child_list_binding(
ctx,
binding,
VueRenderChildListSource::SlotPartitionChildren,
);
}
}
fn insert_render_child_list_binding(
ctx: &mut VueRecoveryContext,
binding: Atom,
source: VueRenderChildListSource,
) {
ctx.render_child_list_bindings
.insert(binding, VueRenderChildListBinding { source });
}
fn member_prop_is_named(prop: &MemberProp, name: &str) -> bool {
member_prop_name(prop)
.as_ref()
.is_some_and(|prop| prop.as_ref() == name)
}
fn member_prop_name(prop: &MemberProp) -> Option<Atom> {
match prop {
MemberProp::Ident(ident) => Some(ident.sym.clone()),
MemberProp::Computed(computed) => string_lit(computed.expr.as_ref()).map(Atom::from),
MemberProp::PrivateName(_) => None,
}
}
fn is_ref_like_value_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
match helper_name(&call.callee, ctx) {
Some(VueHelper::Computed) => return true,
Some(VueHelper::Other(name)) if is_ref_like_vue_helper(&name) => return true,
_ => {}
}
call_callee_ident(call).is_some_and(|callee| {
ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee)
})
}
fn should_emit_ref_script_setup_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
binding: &Ident,
value_member_refs: &HashSet<(Atom, SyntaxContext)>,
) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
match helper_name(&call.callee, ctx) {
Some(VueHelper::Computed) => return true,
Some(VueHelper::Other(name)) if is_ref_like_vue_helper(&name) => return true,
_ => {}
}
call_callee_ident(call).is_some_and(|callee| {
ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee)
}) && value_member_refs.contains(&(binding.sym.clone(), binding.ctxt))
}
fn is_ref_like_vue_helper(name: &str) -> bool {
matches!(
name,
"ref" | "shallowRef" | "customRef" | "toRef" | "useModel"
)
}
fn ref_script_setup_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Result<Option<(String, String, bool)>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return Ok(None);
};
let Some(helper) = ref_script_setup_helper(call, ctx) else {
return Ok(None);
};
let mut args = Vec::new();
for arg in &call.args {
let mut printed = clean_expr(&print_expr(arg.expr.as_ref(), ctx)?, ctx);
if arg.spread.is_some() {
printed = format!("...{printed}");
}
args.push(printed);
}
let known_ref = helper_name(&call.callee, ctx).is_some_and(
|helper| matches!(helper, VueHelper::Other(name) if is_ref_like_vue_helper(&name)),
);
Ok(Some((
format!("{helper}({})", args.join(", ")),
helper,
known_ref,
)))
}
fn ref_script_setup_helper(call: &CallExpr, ctx: &VueRecoveryContext) -> Option<String> {
match helper_name(&call.callee, ctx) {
Some(VueHelper::Other(name)) if is_ref_like_vue_helper(&name) => Some(name),
_ => call_callee_ident(call)
.filter(|&callee| {
ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee)
})
.map(|_| "ref".to_string()),
}
}
pub(super) fn is_ref_object_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
match helper_name(&call.callee, ctx) {
Some(VueHelper::Other(name)) if is_ref_object_helper(&name) => return true,
_ => {}
}
call_callee_ident(call).is_some_and(|callee| {
ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee)
})
}
pub(super) fn is_ref_object_alias(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Ident(ident) = unwrap_paren_expr(expr) else {
return false;
};
ctx.bindings.ref_objects.contains(&ident.sym)
}
fn is_ref_member_extraction_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
provider_ref_object_bindings: &HashMap<Atom, HashSet<Atom>>,
) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
if is_ref_object_expr(member.obj.as_ref(), ctx) || is_ref_object_alias(member.obj.as_ref(), ctx)
{
return true;
}
let Some(prop) = member_prop_name(&member.prop) else {
return false;
};
setup_ref_props(member.obj.as_ref(), ctx, provider_ref_object_bindings)
.is_some_and(|props| props.contains(&prop))
}
fn is_composable_ref_member_extraction_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
bindings: &HashMap<Atom, HashSet<Atom>>,
) -> bool {
let Expr::Member(member) = unwrap_paren_expr(expr) else {
return false;
};
let Some(prop) = member_prop_name(&member.prop) else {
return false;
};
setup_composable_ref_props(member.obj.as_ref(), ctx, bindings)
.is_some_and(|props| props.contains(&prop))
}
fn is_ref_object_helper(name: &str) -> bool {
matches!(name, "toRefs" | "storeToRefs")
}
fn is_script_import_call_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return false;
};
call_callee_ident(call).is_some_and(|callee| ctx.script_imports.contains_key(&callee.sym))
}
fn provider_ref_props_from_init(expr: &Expr, ctx: &VueRecoveryContext) -> Option<HashSet<Atom>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return None;
};
call.args
.iter()
.filter_map(|arg| provider_ref_props_from_callback(arg.expr.as_ref(), ctx))
.find(|ref_props| !ref_props.is_empty())
}
fn provider_ref_props_from_callback(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Option<HashSet<Atom>> {
match unwrap_paren_expr(expr) {
Expr::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => {
provider_ref_props_from_stmts(block.stmts.as_slice(), ctx)
}
BlockStmtOrExpr::Expr(expr) => provider_ref_props_from_return_expr(expr.as_ref(), ctx),
},
Expr::Fn(function) => function
.function
.body
.as_ref()
.and_then(|body| provider_ref_props_from_stmts(body.stmts.as_slice(), ctx)),
_ => None,
}
}
fn provider_ref_props_from_stmts(
stmts: &[Stmt],
ctx: &VueRecoveryContext,
) -> Option<HashSet<Atom>> {
let refs = collect_provider_ref_bindings(stmts, ctx);
let object = stmts.iter().rev().find_map(return_expr_from_stmt)?;
provider_ref_props_from_return_expr_with_refs(object, &refs, ctx)
}
fn provider_ref_props_from_return_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Option<HashSet<Atom>> {
let refs = HashSet::new();
provider_ref_props_from_return_expr_with_refs(expr, &refs, ctx)
}
fn provider_ref_props_from_return_expr_with_refs(
expr: &Expr,
refs: &HashSet<Atom>,
ctx: &VueRecoveryContext,
) -> Option<HashSet<Atom>> {
let Expr::Object(object) = unwrap_paren_expr(expr) else {
return None;
};
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 refs.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) => refs.contains(&value.sym),
_ => is_ref_like_value_expr(value, ctx),
};
if !is_ref_value {
continue;
}
if let Some(name) = prop_name(&key_value.key) {
ref_props.insert(Atom::from(name));
}
}
_ => {}
}
}
(!ref_props.is_empty()).then_some(ref_props)
}
fn collect_provider_ref_bindings(stmts: &[Stmt], ctx: &VueRecoveryContext) -> HashSet<Atom> {
let mut ref_bindings = HashSet::new();
let mut ref_object_bindings = HashSet::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
for decl in &var.decls {
let Some(init) = decl.init.as_deref() else {
continue;
};
match &decl.name {
Pat::Ident(binding) => {
if is_ref_object_expr(init, ctx) {
ref_object_bindings.insert(binding.id.sym.clone());
}
if is_ref_like_value_expr(init, ctx)
|| ident_expr(unwrap_paren_expr(init))
.is_some_and(|ident| ref_bindings.contains(&ident.sym))
{
ref_bindings.insert(binding.id.sym.clone());
}
}
Pat::Object(object)
if is_ref_object_expr(init, ctx)
|| is_provider_ref_object_alias(init, &ref_object_bindings) =>
{
collect_object_pat_bindings(object, &mut ref_bindings);
}
_ => {}
}
}
}
ref_bindings
}
fn is_provider_ref_object_alias(expr: &Expr, ref_object_bindings: &HashSet<Atom>) -> bool {
let Expr::Ident(ident) = unwrap_paren_expr(expr) else {
return false;
};
ref_object_bindings.contains(&ident.sym)
}
fn setup_ref_props(
expr: &Expr,
ctx: &VueRecoveryContext,
bindings: &HashMap<Atom, HashSet<Atom>>,
) -> Option<HashSet<Atom>> {
provider_ref_props_from_expr(expr, ctx)
.cloned()
.or_else(|| direct_composable_ref_props(expr, ctx))
.or_else(|| provider_ref_props_from_alias(expr, bindings).cloned())
}
fn setup_composable_ref_props(
expr: &Expr,
ctx: &VueRecoveryContext,
bindings: &HashMap<Atom, HashSet<Atom>>,
) -> Option<HashSet<Atom>> {
direct_composable_ref_props(expr, ctx).or_else(|| ref_props_from_alias(expr, bindings).cloned())
}
fn direct_composable_ref_props(expr: &Expr, ctx: &VueRecoveryContext) -> Option<HashSet<Atom>> {
imported_composable_ref_props_from_expr(expr, ctx)
.cloned()
.or_else(|| imports::composable_ref_props_from_iife_call(expr))
}
fn imported_composable_ref_props_from_expr<'a>(
expr: &Expr,
ctx: &'a VueRecoveryContext,
) -> Option<&'a HashSet<Atom>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return None;
};
let callee = call_callee_ident(call)?;
ctx.imported_composable_ref_props.get(&callee.sym)
}
fn provider_ref_props_from_expr<'a>(
expr: &Expr,
ctx: &'a VueRecoveryContext,
) -> Option<&'a HashSet<Atom>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return None;
};
let Callee::Expr(callee) = &call.callee else {
return None;
};
let Expr::Member(member) = unwrap_paren_expr(callee.as_ref()) else {
return None;
};
if !is_provider_ref_method(&member.prop) {
return None;
}
let Expr::Ident(provider) = unwrap_paren_expr(member.obj.as_ref()) else {
return None;
};
ctx.provider_ref_bindings.get(&provider.sym)
}
fn is_provider_ref_method(prop: &MemberProp) -> bool {
matches!(prop, MemberProp::Ident(prop) if matches!(prop.sym.as_ref(), "provide" | "inject"))
}
fn provider_ref_props_from_alias<'a>(
expr: &Expr,
bindings: &'a HashMap<Atom, HashSet<Atom>>,
) -> Option<&'a HashSet<Atom>> {
ref_props_from_alias(expr, bindings)
}
fn ref_props_from_alias<'a>(
expr: &Expr,
bindings: &'a HashMap<Atom, HashSet<Atom>>,
) -> Option<&'a HashSet<Atom>> {
let Expr::Ident(ident) = unwrap_paren_expr(expr) else {
return None;
};
bindings.get(&ident.sym)
}
fn collect_object_pat_bindings(object: &ObjectPat, bindings: &mut HashSet<Atom>) {
for prop in &object.props {
match prop {
ObjectPatProp::KeyValue(key_value) => {
collect_pat_bindings(key_value.value.as_ref(), bindings);
}
ObjectPatProp::Assign(assign) => {
bindings.insert(assign.key.sym.clone());
}
ObjectPatProp::Rest(rest) => collect_pat_bindings(rest.arg.as_ref(), bindings),
}
}
}
fn collect_named_object_pat_bindings(object: &ObjectPat, name: &str, bindings: &mut HashSet<Atom>) {
for prop in &object.props {
match prop {
ObjectPatProp::KeyValue(key_value)
if prop_name(&key_value.key).as_deref() == Some(name) =>
{
collect_pat_bindings(key_value.value.as_ref(), bindings);
}
ObjectPatProp::Assign(assign) if assign.key.sym.as_ref() == name => {
bindings.insert(assign.key.sym.clone());
}
_ => {}
}
}
}
fn collect_provider_object_pat_bindings(
object: &ObjectPat,
ref_props: &HashSet<Atom>,
bindings: &mut HashSet<Atom>,
) {
for prop in &object.props {
match prop {
ObjectPatProp::KeyValue(key_value) => {
let Some(name) = prop_name(&key_value.key) else {
continue;
};
if ref_props.iter().any(|prop| prop.as_ref() == name.as_str()) {
collect_pat_bindings(key_value.value.as_ref(), bindings);
}
}
ObjectPatProp::Assign(assign) => {
if ref_props.contains(&assign.key.sym) {
bindings.insert(assign.key.sym.clone());
}
}
ObjectPatProp::Rest(_) => {}
}
}
}
fn collect_pat_bindings(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_bindings(elem, bindings);
}
}
Pat::Rest(rest) => collect_pat_bindings(rest.arg.as_ref(), bindings),
Pat::Object(object) => collect_object_pat_bindings(object, bindings),
Pat::Assign(assign) => collect_pat_bindings(assign.left.as_ref(), bindings),
Pat::Expr(_) | Pat::Invalid(_) => {}
}
}
pub(super) fn render_context_param(render: RenderSource<'_>) -> Option<Atom> {
match render {
RenderSource::Function { render, .. } => render
.function
.params
.first()
.and_then(param_binding_ident)
.map(|ident| ident.sym.clone()),
RenderSource::SetupArrow { render, .. } => {
render.params.first().and_then(|param| match param {
Pat::Ident(binding) => Some(binding.id.sym.clone()),
_ => None,
})
}
}
}
pub(super) fn render_setup_context_param(render: RenderSource<'_>) -> Option<Atom> {
match render {
RenderSource::Function { render, .. } => render
.function
.params
.get(3)
.and_then(param_binding_ident)
.map(|ident| ident.sym.clone()),
RenderSource::SetupArrow { .. } => None,
}
}
pub(super) fn render_props_context_param(render: RenderSource<'_>) -> Option<Atom> {
match render {
RenderSource::Function { render, .. } => render
.function
.params
.get(2)
.and_then(param_binding_ident)
.map(|ident| ident.sym.clone()),
RenderSource::SetupArrow { .. } => None,
}
}
fn render_stmts(render: RenderSource<'_>) -> Option<&[Stmt]> {
match render {
RenderSource::Function { render, .. } => render
.function
.body
.as_ref()
.map(|body| body.stmts.as_slice()),
RenderSource::SetupArrow { render, .. } => match render.body.as_ref() {
BlockStmtOrExpr::BlockStmt(block) => Some(block.stmts.as_slice()),
BlockStmtOrExpr::Expr(_) => None,
},
}
}
fn refresh_setup_value_binding_sources(ctx: &mut VueRecoveryContext) -> Result<()> {
let bindings = ctx.bindings.values.clone();
for (binding, value) in bindings {
let Some(expr) = value.expr else {
continue;
};
let value = clean_expr(&print_expr(&expr, ctx)?, ctx);
if let Some(binding) = ctx.bindings.values.get_mut(&binding) {
binding.value = value;
}
}
Ok(())
}
fn computed_value_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Result<Option<VueSetupValueBinding>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return Ok(None);
};
if !is_computed_call(call, ctx) {
return Ok(None);
}
let Some(arg) = call.args.first() else {
return Ok(None);
};
let Some(binding) = computed_getter_expr(arg.expr.as_ref(), ctx)? else {
return Ok(None);
};
if should_inline_computed_template_binding(&binding) {
Ok(Some(binding))
} else {
Ok(None)
}
}
fn should_inline_computed_template_binding(binding: &VueSetupValueBinding) -> bool {
!computed_value_contains_block_function(&binding.value)
&& !should_preserve_long_computed_template_binding(&binding.value)
}
fn computed_value_contains_block_function(value: &str) -> bool {
value.contains("function") || value_contains_block_arrow(value)
}
fn should_preserve_long_computed_template_binding(value: &str) -> bool {
let mut value = value.trim();
while let Some(inner) = value.strip_prefix('(') {
value = inner.trim_start();
}
// Keep class/style-friendly literal values inline; preserve long computed
// expressions where a named binding is usually easier to read.
value.len() > MAX_INLINE_COMPUTED_TEMPLATE_BINDING_LEN
&& !value.starts_with('[')
&& !value.starts_with('{')
}
fn value_contains_block_arrow(value: &str) -> bool {
let mut cursor = 0;
while let Some(relative_arrow) = value[cursor..].find("=>") {
let arrow = cursor + relative_arrow + "=>".len();
let rest = &value[arrow..];
let body = rest.trim_start();
if body.starts_with('{') {
return true;
}
cursor = arrow;
}
false
}
fn computed_script_setup_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Result<Option<(String, HashSet<Atom>)>> {
let Expr::Call(call) = unwrap_paren_expr(expr) else {
return Ok(None);
};
let Some(arg) = call.args.first() else {
return Ok(None);
};
if !is_computed_script_setup_call(call, arg.expr.as_ref(), ctx) {
return Ok(None);
}
let getter = computed_script_setup_getter(arg.expr.as_ref(), ctx)?;
let import_refs = script_import_refs(arg.expr.as_ref(), &ctx.script_imports);
Ok(Some((format!("computed({getter})"), import_refs)))
}
fn computed_script_setup_getter(expr: &Expr, ctx: &VueRecoveryContext) -> Result<String> {
let getter = clean_expr(&print_expr(expr, ctx)?, ctx);
if arrow_returns_object_expr(expr) {
Ok(wrap_arrow_object_return(&getter))
} else {
Ok(getter)
}
}
fn arrow_returns_object_expr(expr: &Expr) -> bool {
let Expr::Arrow(arrow) = unwrap_paren_expr(expr) else {
return false;
};
matches!(
arrow.body.as_ref(),
BlockStmtOrExpr::Expr(expr) if matches!(unwrap_paren_expr(expr.as_ref()), Expr::Object(_))
)
}
fn wrap_arrow_object_return(getter: &str) -> String {
let Some(arrow_index) = getter.find("=>") else {
return getter.to_string();
};
let body_start = arrow_index + "=>".len();
let leading_ws = getter[body_start..]
.chars()
.take_while(|ch| ch.is_whitespace())
.map(char::len_utf8)
.sum::<usize>();
let object_start = body_start + leading_ws;
if !getter[object_start..].starts_with('{') {
return getter.to_string();
}
let mut output = String::with_capacity(getter.len() + 2);
output.push_str(&getter[..object_start]);
output.push('(');
output.push_str(&getter[object_start..]);
output.push(')');
output
}
fn is_computed_script_setup_call(call: &CallExpr, getter: &Expr, ctx: &VueRecoveryContext) -> bool {
let is_getter = matches!(unwrap_paren_expr(getter), Expr::Arrow(_) | Expr::Fn(_));
if !is_getter {
return false;
}
helper_name(&call.callee, ctx) == Some(VueHelper::Computed)
|| call_callee_ident(call).is_some_and(|callee| {
ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee)
})
}
fn script_import_refs(expr: &Expr, imports: &HashMap<Atom, VueScriptImport>) -> HashSet<Atom> {
let declared = declared_binding_idents(expr);
let mut collector = ScriptImportRefCollector {
imports,
declared: &declared,
refs: HashSet::new(),
};
expr.visit_with(&mut collector);
collector.refs
}
fn stmt_import_refs(stmt: &Stmt, imports: &HashMap<Atom, VueScriptImport>) -> HashSet<Atom> {
let declared = declared_binding_idents(stmt);
let mut collector = ScriptImportRefCollector {
imports,
declared: &declared,
refs: HashSet::new(),
};
stmt.visit_with(&mut collector);
collector.refs
}
pub(super) fn stmt_ident_refs(stmt: &Stmt) -> HashSet<Atom> {
let declared = declared_binding_idents(stmt);
let mut collector = IdentRefCollector {
declared: &declared,
refs: HashSet::new(),
};
stmt.visit_with(&mut collector);
collector.refs
}
fn expr_ident_refs(expr: &Expr) -> HashSet<Atom> {
let declared = declared_binding_idents(expr);
let mut collector = IdentRefCollector {
declared: &declared,
refs: HashSet::new(),
};
expr.visit_with(&mut collector);
collector.refs
}
/// Collect the `(name, SyntaxContext)` of every binding *declared* within a
/// subtree: `var`/`let`/`const` names, function/arrow/method params, catch
/// params, and `fn`/`class` declaration names. Assignment targets (`x = ...`) are
/// references to existing bindings, not declarations, and are deliberately
/// excluded — the old `ScopeStack` collectors special-cased this via
/// `visit_assign_expr_refs`; under resolver it is free because the target and its
/// declaration share one binding identity.
///
/// The key is the `(name, ctxt)` pair, not `ctxt` alone: `resolver()` assigns one
/// context per *scope*, so every binding declared in the same scope shares a
/// context. Keying on the pair distinguishes sibling bindings — the same binding
/// identity used elsewhere in recovery.
fn declared_binding_idents<N>(node: &N) -> HashSet<(Atom, SyntaxContext)>
where
N: VisitWith<DeclaredBindingIdents>,
{
let mut collector = DeclaredBindingIdents {
idents: HashSet::new(),
};
node.visit_with(&mut collector);
collector.idents
}
struct DeclaredBindingIdents {
idents: HashSet<(Atom, SyntaxContext)>,
}
impl DeclaredBindingIdents {
fn record_pat(&mut self, pat: &Pat) {
collect_pat_binding_idents(pat, &mut self.idents);
}
}
impl Visit for DeclaredBindingIdents {
fn visit_var_declarator(&mut self, declarator: &VarDeclarator) {
self.record_pat(&declarator.name);
declarator.visit_children_with(self);
}
fn visit_param(&mut self, param: &Param) {
self.record_pat(¶m.pat);
param.visit_children_with(self);
}
fn visit_arrow_expr(&mut self, arrow: &ArrowExpr) {
for param in &arrow.params {
self.record_pat(param);
}
arrow.visit_children_with(self);
}
fn visit_catch_clause(&mut self, catch: &CatchClause) {
if let Some(param) = &catch.param {
self.record_pat(param);
}
catch.visit_children_with(self);
}
fn visit_fn_decl(&mut self, function: &FnDecl) {
self.idents
.insert((function.ident.sym.clone(), function.ident.ctxt));
function.visit_children_with(self);
}
fn visit_class_decl(&mut self, class: &ClassDecl) {
self.idents
.insert((class.ident.sym.clone(), class.ident.ctxt));
class.visit_children_with(self);
}
}
/// Collects identifier references that are *free* in the walked subtree — those
/// whose `(name, ctxt)` binding identity is not among [`declared_binding_idents`].
/// Runs on resolver-processed ASTs, so this is exactly the shadow-safe reference
/// set the old `ScopeStack` collector computed, without the declare-as-you-go
/// bookkeeping.
struct IdentRefCollector<'a> {
declared: &'a HashSet<(Atom, SyntaxContext)>,
refs: HashSet<Atom>,
}
impl Visit for IdentRefCollector<'_> {
fn visit_ident(&mut self, ident: &Ident) {
if !self.declared.contains(&(ident.sym.clone(), ident.ctxt)) {
self.refs.insert(ident.sym.clone());
}
}
fn visit_prop_name(&mut self, prop: &PropName) {
if let PropName::Computed(computed) = prop {
computed.visit_with(self);
}
}
fn visit_member_prop(&mut self, prop: &MemberProp) {
if let MemberProp::Computed(computed) = prop {
computed.visit_with(self);
}
}
}
/// Like [`IdentRefCollector`] but limited to references that resolve to a script
/// import binding.
struct ScriptImportRefCollector<'a> {
imports: &'a HashMap<Atom, VueScriptImport>,
declared: &'a HashSet<(Atom, SyntaxContext)>,
refs: HashSet<Atom>,
}
impl Visit for ScriptImportRefCollector<'_> {
fn visit_ident(&mut self, ident: &Ident) {
if self.imports.contains_key(&ident.sym)
&& !self.declared.contains(&(ident.sym.clone(), ident.ctxt))
{
self.refs.insert(ident.sym.clone());
}
}
fn visit_prop_name(&mut self, prop: &PropName) {
if let PropName::Computed(computed) = prop {
computed.visit_with(self);
}
}
fn visit_member_prop(&mut self, prop: &MemberProp) {
if let MemberProp::Computed(computed) = prop {
computed.visit_with(self);
}
}
}
fn is_computed_call(call: &CallExpr, ctx: &VueRecoveryContext) -> bool {
if helper_name(&call.callee, ctx) == Some(VueHelper::Computed) {
return true;
}
call_callee_ident(call).is_some_and(|callee| {
ctx.vue_helper_candidates.contains(&callee.sym) && ctx.resolves_to_import(callee)
})
}
fn computed_getter_expr(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Result<Option<VueSetupValueBinding>> {
let Expr::Arrow(arrow) = unwrap_paren_expr(expr) else {
return Ok(None);
};
match arrow.body.as_ref() {
BlockStmtOrExpr::Expr(expr) => Ok(Some(VueSetupValueBinding {
value: clean_expr(&print_expr(expr.as_ref(), ctx)?, ctx),
expr: Some(*expr.clone()),
})),
BlockStmtOrExpr::BlockStmt(block) => computed_block_value_expr(&block.stmts, ctx),
}
}
fn computed_block_value_expr(
stmts: &[Stmt],
ctx: &VueRecoveryContext,
) -> Result<Option<VueSetupValueBinding>> {
if let Some(expr) = computed_if_return_chain_expr(stmts, ctx)? {
return Ok(Some(VueSetupValueBinding {
value: expr,
expr: None,
}));
}
let Some((return_index, expr)) = computed_final_return_expr(stmts) else {
return Ok(None);
};
let prior_stmts = &stmts[..return_index];
if let Some(expr) = computed_array_push_expr(prior_stmts, expr, ctx)? {
return Ok(Some(expr));
}
if !computed_prior_stmts_are_inlineable(prior_stmts, ctx) {
return Ok(None);
}
let local_exprs = computed_block_local_exprs(prior_stmts);
let mutated_locals = computed_mutated_local_bindings(prior_stmts, &local_exprs);
if computed_local_ref_counts(expr, &mutated_locals)
.values()
.any(|count| *count > 0)
{
return Ok(None);
}
let expr = inline_computed_block_locals(expr, prior_stmts);
let local_exprs = computed_block_local_exprs(prior_stmts);
if computed_local_ref_counts(&expr, &local_exprs)
.values()
.any(|count| *count > 0)
{
return Ok(None);
}
let expr = inline_computed_setup_prop_aliases(&expr, &stmts[..return_index], ctx);
Ok(Some(VueSetupValueBinding {
value: clean_expr(&print_expr(&expr, ctx)?, ctx),
expr: Some(expr),
}))
}
fn computed_prior_stmts_are_inlineable(stmts: &[Stmt], ctx: &VueRecoveryContext) -> bool {
stmts.iter().all(|stmt| match stmt {
Stmt::Decl(Decl::Var(var)) => {
if var.kind != VarDeclKind::Const || var.decls.is_empty() {
return false;
}
var.decls.iter().all(|decl| {
decl.init.is_some()
&& (matches!(decl.name, Pat::Ident(_))
|| matches!(decl.name, Pat::Object(_))
&& decl
.init
.as_deref()
.is_some_and(|init| is_setup_props_alias(init, ctx)))
})
}
_ => false,
})
}
fn computed_array_push_expr(
stmts: &[Stmt],
return_expr: &Expr,
ctx: &VueRecoveryContext,
) -> Result<Option<VueSetupValueBinding>> {
let Expr::Ident(return_ident) = unwrap_paren_expr(return_expr) else {
return Ok(None);
};
let Some((array_name, push_stmts)) = computed_array_builder_binding(stmts) else {
return Ok(None);
};
if return_ident.sym != array_name {
return Ok(None);
}
let Some(elems) = computed_array_push_elements(push_stmts, &array_name) else {
return Ok(None);
};
let expr = Expr::Array(ArrayLit {
span: DUMMY_SP,
elems: elems.into_iter().map(Some).collect(),
});
let expr = inline_computed_setup_prop_aliases(&expr, stmts, ctx);
Ok(Some(VueSetupValueBinding {
value: clean_expr(&print_expr(&expr, ctx)?, ctx),
expr: Some(expr),
}))
}
fn computed_array_builder_binding(stmts: &[Stmt]) -> Option<(Atom, &[Stmt])> {
let [first, rest @ ..] = stmts else {
return None;
};
let Stmt::Decl(Decl::Var(var)) = first else {
return None;
};
if var.kind != VarDeclKind::Const {
return None;
}
let [decl] = var.decls.as_slice() else {
return None;
};
let Pat::Ident(binding) = &decl.name else {
return None;
};
let init = decl.init.as_deref()?;
if !is_empty_array_expr(init) {
return None;
}
Some((binding.id.sym.clone(), rest))
}
fn is_empty_array_expr(expr: &Expr) -> bool {
match unwrap_paren_expr(expr) {
Expr::Array(array) => array.elems.is_empty(),
_ => false,
}
}
fn computed_array_push_elements(stmts: &[Stmt], array_name: &Atom) -> Option<Vec<ExprOrSpread>> {
let mut elems = Vec::new();
for stmt in stmts {
elems.extend(computed_array_push_stmt_elements(stmt, array_name)?);
}
Some(elems)
}
fn computed_array_push_stmt_elements(stmt: &Stmt, array_name: &Atom) -> Option<Vec<ExprOrSpread>> {
if let Some(expr) = computed_array_push_arg(stmt, array_name) {
return Some(vec![ExprOrSpread {
spread: None,
expr: Box::new(expr.clone()),
}]);
}
let Stmt::If(if_stmt) = stmt else {
return None;
};
Some(vec![ExprOrSpread {
spread: Some(DUMMY_SP),
expr: Box::new(Expr::Paren(ParenExpr {
span: DUMMY_SP,
expr: Box::new(Expr::Cond(CondExpr {
span: DUMMY_SP,
test: if_stmt.test.clone(),
cons: Box::new(array_expr_from_push_branch(&if_stmt.cons, array_name)?),
alt: Box::new(if_stmt.alt.as_deref().map_or_else(
|| Some(empty_array_expr()),
|alt| array_expr_from_push_branch(alt, array_name),
)?),
})),
})),
}])
}
fn computed_array_push_arg<'a>(stmt: &'a Stmt, array_name: &Atom) -> Option<&'a Expr> {
let Stmt::Expr(expr_stmt) = stmt else {
return None;
};
let Expr::Call(call) = unwrap_paren_expr(expr_stmt.expr.as_ref()) else {
return None;
};
if call.args.len() != 1 || call.args.first()?.spread.is_some() {
return None;
}
let Callee::Expr(callee) = &call.callee else {
return None;
};
let Expr::Member(member) = unwrap_paren_expr(callee.as_ref()) else {
return None;
};
if !matches!(member.obj.as_ref(), Expr::Ident(object) if object.sym == *array_name) {
return None;
}
if !matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "push") {
return None;
}
call.args.first().map(|arg| arg.expr.as_ref())
}
fn array_expr_from_push_branch(stmt: &Stmt, array_name: &Atom) -> Option<Expr> {
let elems = match stmt {
Stmt::Block(block) => computed_array_push_elements(&block.stmts, array_name)?,
stmt => computed_array_push_stmt_elements(stmt, array_name)?,
};
Some(Expr::Array(ArrayLit {
span: DUMMY_SP,
elems: elems.into_iter().map(Some).collect(),
}))
}
fn empty_array_expr() -> Expr {
Expr::Array(ArrayLit {
span: DUMMY_SP,
elems: Vec::new(),
})
}
fn computed_final_return_expr(stmts: &[Stmt]) -> Option<(usize, &Expr)> {
stmts
.iter()
.enumerate()
.rev()
.find_map(|(index, stmt)| match stmt {
Stmt::Return(ReturnStmt {
arg: Some(expr), ..
}) => Some((index, expr.as_ref())),
_ => None,
})
}
fn inline_computed_block_locals(expr: &Expr, stmts: &[Stmt]) -> Expr {
let mut locals = computed_block_local_exprs(stmts);
if locals.is_empty() {
return expr.clone();
}
let mut expr = expr.clone();
while !locals.is_empty() {
let counts = computed_local_ref_counts(&expr, &locals);
let inline_bindings = locals
.iter()
.filter(|(name, expr)| {
counts.get(*name).copied().unwrap_or_default() == 1
&& computed_local_ref_counts(expr, &locals)
.values()
.all(|count| *count == 0)
})
.map(|(name, expr)| (name.clone(), expr.clone()))
.collect::<HashMap<_, _>>();
if inline_bindings.is_empty() {
break;
}
for name in inline_bindings.keys() {
locals.remove(name);
}
expr.visit_mut_with(&mut ComputedLocalInliner::new(inline_bindings));
}
expr
}
fn inline_computed_setup_prop_aliases(
expr: &Expr,
stmts: &[Stmt],
ctx: &VueRecoveryContext,
) -> Expr {
let aliases = computed_setup_prop_alias_exprs(stmts, ctx);
if aliases.is_empty() {
return expr.clone();
}
inline_computed_alias_expr(expr, &aliases)
}
fn computed_setup_prop_alias_exprs(
stmts: &[Stmt],
ctx: &VueRecoveryContext,
) -> HashMap<Atom, Expr> {
let mut aliases = HashMap::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
if var.kind != VarDeclKind::Const {
continue;
}
for decl in &var.decls {
let Pat::Object(object) = &decl.name else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
if !is_setup_props_alias(init, ctx) {
continue;
}
collect_computed_setup_prop_aliases(object, &mut aliases);
}
}
aliases
}
fn collect_computed_setup_prop_alias_var(
var: &VarDecl,
ctx: &VueRecoveryContext,
aliases: &mut HashMap<Atom, Expr>,
) -> bool {
if var.kind != VarDeclKind::Const || var.decls.is_empty() {
return false;
}
let mut next_aliases = HashMap::new();
for decl in &var.decls {
let Pat::Object(object) = &decl.name else {
return false;
};
let Some(init) = decl.init.as_deref() else {
return false;
};
if !is_setup_props_alias(init, ctx) {
return false;
}
if !collect_computed_setup_prop_aliases(object, &mut next_aliases) {
return false;
}
}
aliases.extend(next_aliases);
true
}
fn collect_computed_setup_prop_aliases(
object: &ObjectPat,
aliases: &mut HashMap<Atom, Expr>,
) -> bool {
let mut next_aliases = HashMap::new();
for prop in &object.props {
match prop {
ObjectPatProp::KeyValue(key_value) => {
let Some(name) =
prop_name(&key_value.key).filter(|name| is_valid_identifier_name(name))
else {
return false;
};
let Some(binding) = ident_binding_from_pat(key_value.value.as_ref()) else {
return false;
};
next_aliases.insert(
binding.sym.clone(),
Expr::Ident(Ident::new(name.into(), DUMMY_SP, Default::default())),
);
}
ObjectPatProp::Assign(assign) => {
let name = assign.key.sym.as_ref();
if !is_valid_identifier_name(name) {
return false;
}
next_aliases.insert(
assign.key.sym.clone(),
Expr::Ident(Ident::new(
assign.key.sym.clone(),
DUMMY_SP,
Default::default(),
)),
);
}
ObjectPatProp::Rest(_) => return false,
}
}
if next_aliases.is_empty() {
return false;
}
aliases.extend(next_aliases);
true
}
fn ident_binding_from_pat(pat: &Pat) -> Option<&Ident> {
match pat {
Pat::Ident(binding) => Some(&binding.id),
Pat::Assign(assign) => ident_binding_from_pat(assign.left.as_ref()),
_ => None,
}
}
fn computed_block_local_exprs(stmts: &[Stmt]) -> HashMap<Atom, Expr> {
let mut locals = HashMap::new();
for stmt in stmts {
let Stmt::Decl(Decl::Var(var)) = stmt else {
continue;
};
if var.kind != VarDeclKind::Const {
continue;
}
for decl in &var.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
locals.insert(binding.id.sym.clone(), init.clone());
}
}
locals
}
fn computed_mutated_local_bindings(
stmts: &[Stmt],
locals: &HashMap<Atom, Expr>,
) -> HashMap<Atom, Expr> {
if locals.is_empty() {
return HashMap::new();
}
let mut detector = ComputedLocalMutationDetector::new(locals.keys().cloned().collect());
for stmt in stmts {
stmt.visit_with(&mut detector);
}
let mutated = detector.finish();
locals
.iter()
.filter_map(|(name, expr)| {
mutated
.contains(name)
.then_some((name.clone(), expr.clone()))
})
.collect()
}
fn computed_local_ref_counts(expr: &Expr, locals: &HashMap<Atom, Expr>) -> HashMap<Atom, usize> {
let mut counter = ComputedLocalRefCounter::new(locals.keys().cloned().collect());
expr.visit_with(&mut counter);
counter.finish()
}
struct ComputedLocalMutationDetector {
bindings: Vec<Atom>,
shadow_depths: Vec<usize>,
mutated: HashSet<Atom>,
}
impl ComputedLocalMutationDetector {
fn new(mut bindings: Vec<Atom>) -> Self {
bindings.sort_by(|left, right| left.as_ref().cmp(right.as_ref()));
bindings.dedup();
let shadow_depths = vec![0; bindings.len()];
Self {
bindings,
shadow_depths,
mutated: HashSet::new(),
}
}
fn finish(self) -> HashSet<Atom> {
self.mutated
}
fn active_index(&self, name: &str) -> Option<usize> {
self.bindings
.iter()
.zip(self.shadow_depths.iter())
.position(|(binding, shadow_depth)| binding.as_ref() == name && *shadow_depth == 0)
}
fn mark_name(&mut self, name: &str) {
if let Some(index) = self.active_index(name) {
self.mutated.insert(self.bindings[index].clone());
}
}
fn mark_member_object(&mut self, member: &MemberExpr) {
if let Expr::Ident(object) = member.obj.as_ref() {
self.mark_name(object.sym.as_ref());
}
}
fn shadowing_indices(&self, params: &[&Pat]) -> Vec<usize> {
let mut param_bindings = HashSet::new();
for param in params {
collect_pat_bindings(param, &mut param_bindings);
}
self.bindings
.iter()
.enumerate()
.filter_map(|(index, binding)| param_bindings.contains(binding).then_some(index))
.collect()
}
fn enter_shadowed(&mut self, indices: &[usize]) {
for index in indices {
self.shadow_depths[*index] += 1;
}
}
fn exit_shadowed(&mut self, indices: &[usize]) {
for index in indices {
self.shadow_depths[*index] -= 1;
}
}
}
impl Visit for ComputedLocalMutationDetector {
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
match &assign.left {
AssignTarget::Simple(SimpleAssignTarget::Ident(binding)) => {
self.mark_name(binding.id.sym.as_ref());
}
AssignTarget::Simple(SimpleAssignTarget::Member(member)) => {
self.mark_member_object(member);
}
_ => {}
}
assign.visit_children_with(self);
}
fn visit_update_expr(&mut self, update: &UpdateExpr) {
match update.arg.as_ref() {
Expr::Ident(ident) => self.mark_name(ident.sym.as_ref()),
Expr::Member(member) => self.mark_member_object(member),
_ => {}
}
update.visit_children_with(self);
}
fn visit_call_expr(&mut self, call: &CallExpr) {
if let Callee::Expr(callee) = &call.callee {
if let Expr::Member(member) = callee.as_ref() {
self.mark_member_object(member);
}
}
call.visit_children_with(self);
}
fn visit_arrow_expr(&mut self, arrow: &swc_core::ecma::ast::ArrowExpr) {
let params = arrow.params.iter().collect::<Vec<_>>();
let shadowed = self.shadowing_indices(¶ms);
self.enter_shadowed(&shadowed);
arrow.body.visit_with(self);
self.exit_shadowed(&shadowed);
}
fn visit_function(&mut self, function: &swc_core::ecma::ast::Function) {
let params = function
.params
.iter()
.map(|param| ¶m.pat)
.collect::<Vec<_>>();
let shadowed = self.shadowing_indices(¶ms);
self.enter_shadowed(&shadowed);
if let Some(body) = function.body.as_ref() {
body.visit_with(self);
}
self.exit_shadowed(&shadowed);
}
}
struct ComputedLocalRefCounter {
bindings: Vec<Atom>,
shadow_depths: Vec<usize>,
counts: Vec<usize>,
}
impl ComputedLocalRefCounter {
fn new(mut bindings: Vec<Atom>) -> Self {
bindings.sort_by(|left, right| left.as_ref().cmp(right.as_ref()));
bindings.dedup();
let shadow_depths = vec![0; bindings.len()];
let counts = vec![0; bindings.len()];
Self {
bindings,
shadow_depths,
counts,
}
}
fn finish(self) -> HashMap<Atom, usize> {
self.bindings.into_iter().zip(self.counts).collect()
}
fn active_index(&self, name: &str) -> Option<usize> {
self.bindings
.iter()
.zip(self.shadow_depths.iter())
.position(|(binding, shadow_depth)| binding.as_ref() == name && *shadow_depth == 0)
}
fn shadowing_indices(&self, params: &[&Pat]) -> Vec<usize> {
let mut param_bindings = HashSet::new();
for param in params {
collect_pat_bindings(param, &mut param_bindings);
}
self.bindings
.iter()
.enumerate()
.filter_map(|(index, binding)| param_bindings.contains(binding).then_some(index))
.collect()
}
fn enter_shadowed(&mut self, indices: &[usize]) {
for index in indices {
self.shadow_depths[*index] += 1;
}
}
fn exit_shadowed(&mut self, indices: &[usize]) {
for index in indices {
self.shadow_depths[*index] -= 1;
}
}
}
impl Visit for ComputedLocalRefCounter {
fn visit_expr(&mut self, expr: &Expr) {
if let Expr::Ident(ident) = expr {
if let Some(index) = self.active_index(ident.sym.as_ref()) {
self.counts[index] += 1;
return;
}
}
expr.visit_children_with(self);
}
fn visit_arrow_expr(&mut self, arrow: &swc_core::ecma::ast::ArrowExpr) {
let params = arrow.params.iter().collect::<Vec<_>>();
let shadowed = self.shadowing_indices(¶ms);
self.enter_shadowed(&shadowed);
arrow.body.visit_with(self);
self.exit_shadowed(&shadowed);
}
fn visit_function(&mut self, function: &swc_core::ecma::ast::Function) {
let params = function
.params
.iter()
.map(|param| ¶m.pat)
.collect::<Vec<_>>();
let shadowed = self.shadowing_indices(¶ms);
self.enter_shadowed(&shadowed);
if let Some(body) = function.body.as_ref() {
body.visit_with(self);
}
self.exit_shadowed(&shadowed);
}
}
struct ComputedLocalInliner {
bindings: Vec<(Atom, Expr)>,
replacement_refs: Vec<HashSet<Atom>>,
shadow_depths: Vec<usize>,
capture_depths: Vec<usize>,
}
impl ComputedLocalInliner {
fn new(mut bindings: HashMap<Atom, Expr>) -> Self {
let mut bindings = bindings.drain().collect::<Vec<_>>();
bindings.sort_by(|(left, _), (right, _)| left.as_ref().cmp(right.as_ref()));
let replacement_refs = bindings
.iter()
.map(|(_, expr)| expr_ident_refs(expr))
.collect::<Vec<_>>();
let shadow_depths = vec![0; bindings.len()];
let capture_depths = vec![0; bindings.len()];
Self {
bindings,
replacement_refs,
shadow_depths,
capture_depths,
}
}
fn active_index(&self, name: &str) -> Option<usize> {
self.bindings
.iter()
.zip(self.shadow_depths.iter())
.zip(self.capture_depths.iter())
.position(|(((binding, _), shadow_depth), capture_depth)| {
binding.as_ref() == name && *shadow_depth == 0 && *capture_depth == 0
})
}
fn shadowing_indices(&self, scope_bindings: &HashSet<Atom>) -> Vec<usize> {
self.bindings
.iter()
.enumerate()
.filter_map(|(index, (binding, _))| scope_bindings.contains(binding).then_some(index))
.collect()
}
fn capture_indices(&self, scope_bindings: &HashSet<Atom>) -> Vec<usize> {
self.replacement_refs
.iter()
.enumerate()
.filter_map(|(index, refs)| {
refs.iter()
.any(|name| scope_bindings.contains(name))
.then_some(index)
})
.collect()
}
fn enter_shadowed(&mut self, indices: &[usize]) {
for index in indices {
self.shadow_depths[*index] += 1;
}
}
fn exit_shadowed(&mut self, indices: &[usize]) {
for index in indices {
self.shadow_depths[*index] -= 1;
}
}
fn enter_captured(&mut self, indices: &[usize]) {
for index in indices {
self.capture_depths[*index] += 1;
}
}
fn exit_captured(&mut self, indices: &[usize]) {
for index in indices {
self.capture_depths[*index] -= 1;
}
}
fn enter_scope(&mut self, scope_bindings: &HashSet<Atom>) -> (Vec<usize>, Vec<usize>) {
let shadowed = self.shadowing_indices(scope_bindings);
let captured = self.capture_indices(scope_bindings);
self.enter_shadowed(&shadowed);
self.enter_captured(&captured);
(shadowed, captured)
}
fn exit_scope(&mut self, shadowed: &[usize], captured: &[usize]) {
self.exit_captured(captured);
self.exit_shadowed(shadowed);
}
}
impl VisitMut for ComputedLocalInliner {
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if let Expr::Ident(ident) = expr {
if let Some(index) = self.active_index(ident.sym.as_ref()) {
*expr = self.bindings[index].1.clone();
expr.visit_mut_children_with(self);
return;
}
}
expr.visit_mut_children_with(self);
}
fn visit_mut_arrow_expr(&mut self, arrow: &mut swc_core::ecma::ast::ArrowExpr) {
let scope_bindings = arrow_scope_bindings(arrow);
let (shadowed, captured) = self.enter_scope(&scope_bindings);
arrow.body.visit_mut_with(self);
self.exit_scope(&shadowed, &captured);
}
fn visit_mut_function(&mut self, function: &mut swc_core::ecma::ast::Function) {
let scope_bindings = function_scope_bindings(function);
let (shadowed, captured) = self.enter_scope(&scope_bindings);
if let Some(body) = function.body.as_mut() {
body.visit_mut_with(self);
}
self.exit_scope(&shadowed, &captured);
}
}
fn arrow_scope_bindings(arrow: &swc_core::ecma::ast::ArrowExpr) -> HashSet<Atom> {
let mut bindings = HashSet::new();
for param in &arrow.params {
collect_pat_bindings(param, &mut bindings);
}
collect_block_or_expr_scope_bindings(arrow.body.as_ref(), &mut bindings);
bindings
}
fn function_scope_bindings(function: &swc_core::ecma::ast::Function) -> HashSet<Atom> {
let mut bindings = HashSet::new();
for param in &function.params {
collect_pat_bindings(¶m.pat, &mut bindings);
}
if let Some(body) = function.body.as_ref() {
collect_stmt_scope_bindings(&body.stmts, &mut bindings);
}
bindings
}
fn collect_block_or_expr_scope_bindings(body: &BlockStmtOrExpr, bindings: &mut HashSet<Atom>) {
if let BlockStmtOrExpr::BlockStmt(block) = body {
collect_stmt_scope_bindings(&block.stmts, bindings);
}
}
fn collect_stmt_scope_bindings(stmts: &[Stmt], bindings: &mut HashSet<Atom>) {
for stmt in stmts {
match stmt {
Stmt::Decl(Decl::Var(var)) => {
for decl in &var.decls {
collect_pat_bindings(&decl.name, bindings);
}
}
Stmt::Decl(Decl::Fn(function)) => {
bindings.insert(function.ident.sym.clone());
}
Stmt::Decl(Decl::Class(class)) => {
bindings.insert(class.ident.sym.clone());
}
Stmt::Block(block) => collect_stmt_scope_bindings(&block.stmts, bindings),
Stmt::If(if_stmt) => {
collect_stmt_scope_binding(if_stmt.cons.as_ref(), bindings);
if let Some(alt) = if_stmt.alt.as_ref() {
collect_stmt_scope_binding(alt.as_ref(), bindings);
}
}
_ => {}
}
}
}
fn collect_stmt_scope_binding(stmt: &Stmt, bindings: &mut HashSet<Atom>) {
match stmt {
Stmt::Block(block) => collect_stmt_scope_bindings(&block.stmts, bindings),
stmt => collect_stmt_scope_bindings(std::slice::from_ref(stmt), bindings),
}
}
fn computed_if_return_chain_expr(
stmts: &[Stmt],
ctx: &VueRecoveryContext,
) -> Result<Option<String>> {
let mut branches = Vec::new();
let mut aliases = HashMap::new();
for stmt in stmts {
match stmt {
Stmt::Decl(Decl::Var(var))
if branches.is_empty()
&& collect_computed_setup_prop_alias_var(var, ctx, &mut aliases) =>
{
continue;
}
Stmt::If(if_stmt) => {
let Some(expr) = direct_return_expr_from_stmt(if_stmt.cons.as_ref()) else {
return Ok(None);
};
if if_stmt.alt.is_some() {
return Ok(None);
}
let test = inline_computed_alias_expr(if_stmt.test.as_ref(), &aliases);
let expr = inline_computed_alias_expr(expr, &aliases);
branches.push((
clean_expr(&print_expr(&test, ctx)?, ctx),
clean_expr(&print_expr(&expr, ctx)?, ctx),
));
}
Stmt::Return(ReturnStmt {
arg: Some(expr), ..
}) if !branches.is_empty() => {
let expr = inline_computed_alias_expr(expr, &aliases);
let fallback = clean_expr(&print_expr(&expr, ctx)?, ctx);
return Ok(Some(format_conditional_expr(&branches, fallback)));
}
_ => return Ok(None),
}
}
Ok(None)
}
fn inline_computed_alias_expr(expr: &Expr, aliases: &HashMap<Atom, Expr>) -> Expr {
if aliases.is_empty() {
return expr.clone();
}
let mut expr = expr.clone();
expr.visit_mut_with(&mut ComputedLocalInliner::new(aliases.clone()));
expr
}
fn return_expr_from_stmt(stmt: &Stmt) -> Option<&Expr> {
match stmt {
Stmt::Return(ReturnStmt {
arg: Some(expr), ..
}) => Some(expr.as_ref()),
Stmt::Block(block) => block.stmts.iter().find_map(return_expr_from_stmt),
_ => None,
}
}
fn direct_return_expr_from_stmt(stmt: &Stmt) -> Option<&Expr> {
match stmt {
Stmt::Return(ReturnStmt {
arg: Some(expr), ..
}) => Some(expr.as_ref()),
Stmt::Block(block) => {
let [Stmt::Return(ReturnStmt {
arg: Some(expr), ..
})] = block.stmts.as_slice()
else {
return None;
};
Some(expr.as_ref())
}
_ => None,
}
}
fn format_conditional_expr(branches: &[(String, String)], fallback: String) -> String {
branches
.iter()
.rev()
.fold(fallback, |alternate, (condition, consequent)| {
format!("{condition} ? {consequent} : {alternate}")
})
}
fn resolve_component_name(expr: &Expr, ctx: &VueRecoveryContext) -> Option<String> {
let Expr::Call(call) = expr else {
return None;
};
if helper_name(&call.callee, ctx) != Some(VueHelper::ResolveComponent) {
return None;
}
call.args
.first()
.and_then(|arg| string_lit(arg.expr.as_ref()))
}
pub(super) fn resolve_directive_name(expr: &Expr, ctx: &VueRecoveryContext) -> Option<String> {
let Expr::Call(call) = expr else {
return None;
};
if helper_name(&call.callee, ctx) != Some(VueHelper::ResolveDirective) {
return None;
}
call.args
.first()
.and_then(|arg| string_lit(arg.expr.as_ref()))
}
#[cfg(test)]
mod tests;