crates/core/src/rules/un_template_literal.rs
GitHubuse std::collections::{HashMap, HashSet};
use swc_core::common::DUMMY_SP;
use swc_core::ecma::ast::{
AssignOp, AssignTarget, BinExpr, BinaryOp, BlockStmtOrExpr, CallExpr, Callee, Decl, Expr, Lit,
MemberExpr, MemberProp, Module, ModuleItem, Pat, SimpleAssignTarget, Stmt, TaggedTpl, Tpl,
TplElement,
};
use swc_core::ecma::utils::ExprFactory;
use swc_core::ecma::visit::{VisitMut, VisitMutWith};
use super::cross_module_helper_refs::{
collect_cross_module_helper_refs, cross_module_member_helper_kind, CrossModuleHelperRefs,
};
use super::helper_matcher::{
binding_key, expr_binding_key, remaining_refs_outside_declarations, remove_fn_decls_by_binding,
remove_import_specifiers_by_binding, remove_var_declarators_by_binding,
var_declarator_binding_key, BindingKey,
};
use super::transpiler_helper_utils::{LocalHelperContext, TranspilerHelperKind};
use super::RewriteLevel;
use crate::facts::ModuleFactsMap;
use crate::utils::paren::strip_parens;
pub struct UnTemplateLiteral<'a> {
level: RewriteLevel,
module_facts: Option<&'a ModuleFactsMap>,
current_filename: Option<&'a str>,
}
impl UnTemplateLiteral<'_> {
pub fn new() -> Self {
Self::new_with_level(RewriteLevel::Standard)
}
pub fn new_with_level(level: RewriteLevel) -> Self {
Self {
level,
module_facts: None,
current_filename: None,
}
}
}
impl<'a> UnTemplateLiteral<'a> {
pub fn new_with_facts(level: RewriteLevel, module_facts: &'a ModuleFactsMap) -> Self {
Self {
level,
module_facts: Some(module_facts),
current_filename: None,
}
}
pub(crate) fn set_current_filename(&mut self, current_filename: Option<&'a str>) {
self.current_filename = current_filename;
}
pub(crate) fn run_with_helpers(
&mut self,
module: &mut Module,
local_helpers: &LocalHelperContext,
) {
let cross_module_helpers = self
.module_facts
.map(|facts| {
collect_cross_module_helper_refs(module, facts, self.current_filename, |kind| {
kind == TranspilerHelperKind::TaggedTemplateLiteral
})
})
.unwrap_or_default();
let detected_helpers: HashSet<BindingKey> = local_helpers
.helpers_of_kind(TranspilerHelperKind::TaggedTemplateLiteral)
.into_keys()
.collect();
let factories =
collect_template_factories(module, &cross_module_helpers, &detected_helpers);
let mut replacer = TaggedTemplateReplacer {
factories: &factories,
cross_module_helpers: &cross_module_helpers,
detected_helpers: &detected_helpers,
consumed_helpers: HashSet::new(),
consumed_caches: HashSet::new(),
consumed_factories: HashSet::new(),
};
module.visit_mut_children_with(&mut replacer);
module.visit_mut_children_with(self);
let mut removable = replacer.consumed_helpers;
removable.extend(replacer.consumed_caches);
removable.extend(replacer.consumed_factories);
if !removable.is_empty() {
remove_unused_template_bindings(module, &removable);
}
}
}
impl Default for UnTemplateLiteral<'_> {
fn default() -> Self {
Self::new()
}
}
enum Part {
Text(String),
Expr(Box<Expr>),
}
#[derive(Clone)]
struct TemplateData {
cooked: Vec<Option<String>>,
raw: Vec<String>,
helper: Option<BindingKey>,
}
struct TemplateMatch {
data: TemplateData,
cache: Option<BindingKey>,
factory: Option<BindingKey>,
}
impl VisitMut for UnTemplateLiteral<'_> {
fn visit_mut_module(&mut self, module: &mut Module) {
let local_helpers = LocalHelperContext::collect(module);
self.run_with_helpers(module, &local_helpers);
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if let Some(next) = rewrite_concat_chain(expr) {
*expr = next;
expr.visit_mut_children_with(self);
} else if let Some(next) = rewrite_plus_chain(expr, self.level) {
*expr = next;
expr.visit_mut_children_with(self);
} else {
expr.visit_mut_children_with(self);
}
if let Expr::Tpl(tpl) = expr {
normalize_escaped_newline_template_raw(tpl, self.level);
}
}
}
struct TaggedTemplateReplacer<'a> {
factories: &'a HashMap<BindingKey, TemplateData>,
cross_module_helpers: &'a CrossModuleHelperRefs,
detected_helpers: &'a HashSet<BindingKey>,
consumed_helpers: HashSet<BindingKey>,
consumed_caches: HashSet<BindingKey>,
consumed_factories: HashSet<BindingKey>,
}
impl VisitMut for TaggedTemplateReplacer<'_> {
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
let Expr::Call(call) = expr else {
return;
};
let Some(next) = rewrite_tagged_template_call(
call,
self.factories,
self.cross_module_helpers,
self.detected_helpers,
&mut self.consumed_helpers,
&mut self.consumed_caches,
&mut self.consumed_factories,
) else {
return;
};
*expr = next;
}
}
fn rewrite_concat_chain(expr: &Expr) -> Option<Expr> {
let Expr::Call(call) = expr else {
return None;
};
let mut parts = Vec::new();
if !collect_concat_parts(call, &mut parts) {
return None;
}
let tpl = parts_to_template(parts, call.span);
Some(Expr::Tpl(tpl))
}
fn collect_concat_parts(call: &CallExpr, out: &mut Vec<Part>) -> bool {
let Callee::Expr(callee_expr) = &call.callee else {
return false;
};
let Expr::Member(MemberExpr { obj, prop, .. }) = &**callee_expr else {
return false;
};
if !matches!(prop, MemberProp::Ident(ident) if ident.sym == "concat") {
return false;
}
match &**obj {
Expr::Call(prev_call) => {
if !collect_concat_parts(prev_call, out) {
return false;
}
}
Expr::Lit(Lit::Str(s)) => out.push(Part::Text(s.value.to_string_lossy().into_owned())),
_ => return false,
}
for arg in &call.args {
if arg.spread.is_some() {
return false;
}
match &*arg.expr {
Expr::Lit(Lit::Str(s)) => out.push(Part::Text(s.value.to_string_lossy().into_owned())),
other => out.push(Part::Expr(Box::new(other.clone()))),
}
}
true
}
fn rewrite_tagged_template_call(
call: &CallExpr,
factories: &HashMap<BindingKey, TemplateData>,
cross_module_helpers: &CrossModuleHelperRefs,
detected_helpers: &HashSet<BindingKey>,
consumed_helpers: &mut HashSet<BindingKey>,
consumed_caches: &mut HashSet<BindingKey>,
consumed_factories: &mut HashSet<BindingKey>,
) -> Option<Expr> {
if call.args.is_empty() || call.args.iter().any(|arg| arg.spread.is_some()) {
return None;
}
let template_match = extract_template_match(
call.args[0].expr.as_ref(),
factories,
cross_module_helpers,
detected_helpers,
)?;
if template_match.data.cooked.len() != call.args.len() {
return None;
}
if let Some(helper) = &template_match.data.helper {
if !cross_module_helpers.direct.contains_key(helper) {
consumed_helpers.insert(helper.clone());
}
}
if let Some(cache) = template_match.cache {
consumed_caches.insert(cache);
}
if let Some(factory) = template_match.factory {
consumed_factories.insert(factory);
}
let Callee::Expr(tag) = &call.callee else {
return None;
};
let exprs = call
.args
.iter()
.skip(1)
.map(|arg| arg.expr.clone())
.collect();
Some(Expr::TaggedTpl(TaggedTpl {
span: call.span,
ctxt: call.ctxt,
tag: tag.clone(),
type_params: call.type_args.clone(),
tpl: Box::new(template_match.data.into_tpl(exprs, call.span)),
}))
}
fn extract_template_match(
expr: &Expr,
factories: &HashMap<BindingKey, TemplateData>,
cross_module_helpers: &CrossModuleHelperRefs,
detected_helpers: &HashSet<BindingKey>,
) -> Option<TemplateMatch> {
let expr = strip_parens(expr);
if let Some((data, helper)) =
extract_direct_template_helper_call(expr, cross_module_helpers, detected_helpers)
{
return Some(TemplateMatch {
data: TemplateData { helper, ..data },
cache: None,
factory: None,
});
}
if let Some((factory, data)) = extract_template_factory_call(expr, factories) {
return Some(TemplateMatch {
data: data.clone(),
cache: None,
factory: Some(factory),
});
}
let Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) = expr
else {
return None;
};
let cache = expr_binding_key(strip_parens(left))?;
let Expr::Assign(assign) = strip_parens(right) else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(target)) = &assign.left else {
return None;
};
let target_key = binding_key(&target.id);
if target_key != cache {
return None;
}
let (data, helper) = extract_direct_template_helper_call(
strip_parens(&assign.right),
cross_module_helpers,
detected_helpers,
)?;
Some(TemplateMatch {
data: TemplateData { helper, ..data },
cache: Some(cache),
factory: None,
})
}
fn extract_template_factory_call<'a>(
expr: &Expr,
factories: &'a HashMap<BindingKey, TemplateData>,
) -> Option<(BindingKey, &'a TemplateData)> {
let Expr::Call(call) = expr else {
return None;
};
if !call.args.is_empty() {
return None;
}
let Callee::Expr(callee) = &call.callee else {
return None;
};
let key = expr_binding_key(strip_parens(callee))?;
factories
.get_key_value(&key)
.map(|(key, data)| (key.clone(), data))
}
fn extract_direct_template_helper_call(
expr: &Expr,
cross_module_helpers: &CrossModuleHelperRefs,
detected_helpers: &HashSet<BindingKey>,
) -> Option<(TemplateData, Option<BindingKey>)> {
let Expr::Call(call) = expr else {
return None;
};
if call.args.is_empty()
|| call.args.len() > 2
|| call.args.iter().any(|arg| arg.spread.is_some())
{
return None;
}
let helper = match &call.callee {
Callee::Expr(callee) => {
let callee = strip_parens(callee);
if let Some(helper) = expr_binding_key(callee) {
if !is_template_helper_name(helper.0.as_ref())
&& !cross_module_helpers.direct.contains_key(&helper)
&& !detected_helpers.contains(&helper)
{
return None;
}
Some(helper)
} else if cross_module_member_helper_kind(callee, &cross_module_helpers.namespaces)
== Some(TranspilerHelperKind::TaggedTemplateLiteral)
|| is_inline_template_helper(callee)
{
None
} else {
return None;
}
}
_ => return None,
};
let cooked = collect_template_array(call.args[0].expr.as_ref())?;
let raw = if call.args.len() == 2 {
collect_template_array(call.args[1].expr.as_ref())?
.into_iter()
.collect::<Option<Vec<_>>>()?
} else {
cooked
.iter()
.map(|value| value.as_deref().map(escape_template_raw_cooked_copy))
.collect::<Option<Vec<_>>>()?
};
if cooked.len() != raw.len() || cooked.is_empty() {
return None;
}
Some((
TemplateData {
cooked,
raw,
helper: None,
},
helper,
))
}
fn is_inline_template_helper(expr: &Expr) -> bool {
match strip_parens(expr) {
Expr::Fn(fn_expr) => {
if fn_expr.function.params.len() != 2 {
return false;
}
if !fn_expr
.function
.params
.iter()
.all(|param| matches!(param.pat, Pat::Ident(_)))
{
return false;
}
fn_expr.function.body.as_ref().is_some_and(|body| {
body.stmts
.iter()
.any(|stmt| matches!(stmt, Stmt::Return(_)))
})
}
Expr::Arrow(arrow) => {
arrow.params.len() == 2
&& arrow
.params
.iter()
.all(|param| matches!(param, Pat::Ident(_)))
&& match arrow.body.as_ref() {
BlockStmtOrExpr::Expr(_) => true,
BlockStmtOrExpr::BlockStmt(body) => body
.stmts
.iter()
.any(|stmt| matches!(stmt, Stmt::Return(_))),
}
}
_ => false,
}
}
/// Convert `"str" + a + b` (binary `+` chains with at least one string literal)
/// into a template literal.
///
/// Safety: only transforms when at least one operand in the chain is a string
/// literal. All non-string elements that appear **before** the first string
/// literal are grouped into a single sub-expression to preserve arithmetic
/// semantics (e.g. `a + b + "c"` → `` `${a + b}c` `` not `` `${a}${b}c` ``).
fn rewrite_plus_chain(expr: &Expr, level: RewriteLevel) -> Option<Expr> {
// Collect the flat left-associative operand list
let mut operands: Vec<&Expr> = Vec::new();
collect_add_chain(expr, &mut operands);
// Must have at least 2 operands and at least one string literal
if operands.len() < 2 {
return None;
}
let first_str_idx = operands.iter().position(|e| is_str_lit(e))?;
if level == RewriteLevel::Minimal && is_empty_str_lit(operands[first_str_idx]) {
return None;
}
// Determine the span for the resulting template
let span = match expr {
Expr::Bin(b) => b.span,
_ => DUMMY_SP,
};
// Build the parts list:
// – everything before the first string literal is grouped into one Expr part
// (to avoid splitting arithmetic sub-expressions like `a + b`)
// – from the first string literal onward, each element becomes Text or Expr
let mut parts: Vec<Part> = Vec::new();
if first_str_idx > 0 {
let grouped = rebuild_add_chain(&operands[..first_str_idx]);
parts.push(Part::Expr(grouped));
}
for op in &operands[first_str_idx..] {
if let Expr::Lit(Lit::Str(s)) = op {
parts.push(Part::Text(s.value.to_string_lossy().into_owned()));
} else {
parts.push(Part::Expr(Box::new((*op).clone())));
}
}
// Must have at least one Expr part — a pure string-literal chain is not worth
// converting (it would just be `\`constant\``).
if !parts.iter().any(|p| matches!(p, Part::Expr(_))) {
return None;
}
Some(Expr::Tpl(parts_to_template(parts, span)))
}
/// Flatten a left-associative `+` chain into individual operands.
fn collect_add_chain<'a>(expr: &'a Expr, out: &mut Vec<&'a Expr>) {
if let Expr::Bin(BinExpr {
op: BinaryOp::Add,
left,
right,
..
}) = expr
{
collect_add_chain(left, out);
out.push(right);
} else {
out.push(expr);
}
}
fn is_str_lit(expr: &Expr) -> bool {
matches!(expr, Expr::Lit(Lit::Str(_)))
}
fn is_empty_str_lit(expr: &Expr) -> bool {
matches!(expr, Expr::Lit(Lit::Str(s)) if s.value.is_empty())
}
fn normalize_escaped_newline_template_raw(tpl: &mut Tpl, level: RewriteLevel) {
if level == RewriteLevel::Minimal {
return;
}
for quasi in &mut tpl.quasis {
if quasi.cooked.is_none() {
continue;
}
let raw = quasi.raw.to_string();
let Some(next) = normalize_newline_escapes(&raw) else {
continue;
};
quasi.raw = next.into();
}
}
fn normalize_newline_escapes(raw: &str) -> Option<String> {
if !raw.contains("\\n") || raw.contains("\\r") {
return None;
}
let mut output = String::with_capacity(raw.len());
let mut chars = raw.chars().peekable();
let mut changed = false;
while let Some(ch) = chars.next() {
if ch != '\\' {
output.push(ch);
continue;
}
match chars.peek().copied() {
Some('n') => {
chars.next();
output.push('\n');
changed = true;
}
Some(next) => {
chars.next();
output.push('\\');
output.push(next);
}
None => output.push('\\'),
}
}
changed.then_some(output)
}
fn collect_template_factories(
module: &Module,
cross_module_helpers: &CrossModuleHelperRefs,
detected_helpers: &HashSet<BindingKey>,
) -> HashMap<BindingKey, TemplateData> {
module
.body
.iter()
.filter_map(|item| {
let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(func))) = item else {
return None;
};
let body = func.function.body.as_ref()?;
let data = extract_template_from_factory_body(
&body.stmts,
cross_module_helpers,
detected_helpers,
)?;
Some((binding_key(&func.ident), data))
})
.collect()
}
fn extract_template_from_factory_body(
stmts: &[Stmt],
cross_module_helpers: &CrossModuleHelperRefs,
detected_helpers: &HashSet<BindingKey>,
) -> Option<TemplateData> {
let mut locals: HashMap<BindingKey, TemplateData> = HashMap::new();
for stmt in stmts {
match stmt {
Stmt::Decl(Decl::Var(var)) => {
for decl in &var.decls {
let Some(key) = var_declarator_binding_key(decl) else {
continue;
};
let Some(init) = decl.init.as_deref() else {
continue;
};
if let Some((data, helper)) = extract_direct_template_helper_call(
init,
cross_module_helpers,
detected_helpers,
) {
locals.insert(key, TemplateData { helper, ..data });
}
}
}
Stmt::Return(ret) => {
let arg = ret.arg.as_deref()?;
if let Some(key) = expr_binding_key(strip_parens(arg)) {
if let Some(data) = locals.get(&key) {
return Some(data.clone());
}
}
if let Some((data, helper)) =
extract_direct_template_helper_call(arg, cross_module_helpers, detected_helpers)
{
return Some(TemplateData { helper, ..data });
}
}
_ => {}
}
}
None
}
fn collect_template_array(expr: &Expr) -> Option<Vec<Option<String>>> {
let Expr::Array(array) = strip_parens(expr) else {
return None;
};
array
.elems
.iter()
.map(|elem| {
let elem = elem.as_ref()?;
if elem.spread.is_some() {
return None;
}
match elem.expr.as_ref() {
Expr::Lit(Lit::Str(s)) => Some(Some(s.value.to_string_lossy().into_owned())),
Expr::Ident(id) if id.sym.as_ref() == "undefined" => Some(None),
Expr::Unary(unary)
if unary.op == swc_core::ecma::ast::UnaryOp::Void
&& matches!(unary.arg.as_ref(), Expr::Lit(Lit::Num(_))) =>
{
Some(None)
}
_ => None,
}
})
.collect()
}
fn is_template_helper_name(name: &str) -> bool {
matches!(
name,
"_taggedTemplateLiteral"
| "_taggedTemplateLiteralLoose"
| "_tagged_template_literal"
| "_tagged_template_literal_loose"
| "__makeTemplateObject"
| "__template"
)
}
/// Re-assemble a slice of expressions into a left-associative `+` chain.
fn rebuild_add_chain(exprs: &[&Expr]) -> Box<Expr> {
debug_assert!(!exprs.is_empty());
let mut acc = Box::new((*exprs[0]).clone());
for e in &exprs[1..] {
acc = Box::new((*acc).make_bin(BinaryOp::Add, (*e).clone()));
}
acc
}
impl TemplateData {
fn into_tpl(self, exprs: Vec<Box<Expr>>, span: swc_core::common::Span) -> Tpl {
let last = self.cooked.len().saturating_sub(1);
let quasis = self
.cooked
.into_iter()
.zip(self.raw)
.enumerate()
.map(|(index, (cooked, raw))| TplElement {
span,
tail: index == last,
cooked: cooked.map(Into::into),
raw: raw.into(),
})
.collect();
Tpl {
span,
exprs,
quasis,
}
}
}
fn parts_to_template(parts: Vec<Part>, span: swc_core::common::Span) -> Tpl {
let mut quasis = Vec::new();
let mut exprs = Vec::new();
let mut current = String::new();
for part in parts {
match part {
Part::Text(text) => current.push_str(&text),
Part::Expr(expr) => {
quasis.push(TplElement {
span,
tail: false,
cooked: Some(current.clone().into()),
raw: escape_template_raw(¤t).into(),
});
current.clear();
exprs.push(expr);
}
}
}
quasis.push(TplElement {
span,
tail: true,
cooked: Some(current.clone().into()),
raw: escape_template_raw(¤t).into(),
});
Tpl {
span,
exprs,
quasis,
}
}
fn escape_template_raw(input: &str) -> String {
input
.replace('\\', "\\\\")
.replace('`', "\\`")
.replace('$', "\\$")
.replace('\n', "\\n")
.replace('\t', "\\t")
.replace('\r', "\\r")
}
fn escape_template_raw_cooked_copy(input: &str) -> String {
input
.replace('\\', "\\\\")
.replace('`', "\\`")
.replace("${", "\\${")
}
fn remove_unused_template_bindings(module: &mut Module, candidates: &HashSet<BindingKey>) {
let remaining = remaining_refs_outside_declarations(module, candidates, candidates);
let unused: HashSet<_> = candidates.difference(&remaining).cloned().collect();
if unused.is_empty() {
return;
}
remove_fn_decls_by_binding(module, &unused);
remove_import_specifiers_by_binding(&mut module.body, &unused);
remove_var_declarators_by_binding(&mut module.body, &unused);
}