crates/core/src/rules/un_jsx.rs
GitHubuse std::collections::{HashMap, HashSet};
use swc_core::atoms::{Atom, Wtf8Atom};
use swc_core::common::{Mark, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
ArrowExpr, AssignExpr, AssignOp, BindingIdent, BlockStmt, Bool, CallExpr, Callee, Decl, Expr,
ExprOrSpread, Ident, ImportDecl, ImportSpecifier, JSXAttr, JSXAttrName, JSXAttrOrSpread,
JSXAttrValue, JSXClosingElement, JSXClosingFragment, JSXElement, JSXElementChild,
JSXElementName, JSXExpr, JSXExprContainer, JSXFragment, JSXMemberExpr, JSXNamespacedName,
JSXObject, JSXOpeningElement, JSXOpeningFragment, JSXSpreadChild, JSXText, KeyValueProp, Lit,
MemberExpr, MemberProp, Module, ModuleDecl, ModuleExportName, ModuleItem, Number, ObjectLit,
Param, Pat, Prop, PropName, PropOrSpread, SpreadElement, Stmt, Str, VarDecl, VarDeclKind,
VarDeclarator,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};
use crate::analysis::binding_uses::BindingUseIndex;
use super::decl_utils::BindingId;
use super::{RewriteLevel, Rule};
const CLASSIC_PRAGMA: &str = "createElement";
fn is_automatic_pragma(name: &str) -> bool {
matches!(
name,
"jsx" | "jsxs" | "_jsx" | "_jsxs" | "jsxDEV" | "jsxsDEV"
)
}
fn is_jsx_pragma_name(name: &str) -> bool {
matches!(
name,
"createElement" | "jsx" | "jsxs" | "_jsx" | "_jsxs" | "jsxDEV" | "jsxsDEV"
)
}
#[derive(Clone)]
struct ScopedRename {
old: BindingId,
new: Atom,
}
pub struct UnJsx {
unresolved_mark: Mark,
level: RewriteLevel,
pending_stmts: Vec<Vec<Stmt>>,
used_names: Vec<HashSet<Atom>>,
string_consts: Vec<HashMap<BindingId, Str>>,
import_pragmas: HashMap<BindingId, &'static str>,
converted_classic_pragma: bool,
}
impl UnJsx {
pub fn new(unresolved_mark: Mark) -> Self {
Self::new_with_level(unresolved_mark, RewriteLevel::Standard)
}
pub fn new_with_level(unresolved_mark: Mark, level: RewriteLevel) -> Self {
Self {
unresolved_mark,
level,
pending_stmts: Vec::new(),
used_names: Vec::new(),
string_consts: Vec::new(),
import_pragmas: HashMap::new(),
converted_classic_pragma: false,
}
}
fn should_run(module: &Module) -> bool {
struct Scan {
found: bool,
}
impl Visit for Scan {
fn visit_import_decl(&mut self, import: &ImportDecl) {
if self.found {
return;
}
if let Some(src) = import.src.value.as_str() {
if matches!(src, "react/jsx-runtime" | "react/jsx-dev-runtime") {
self.found = true;
}
}
}
fn visit_call_expr(&mut self, call: &CallExpr) {
if self.found {
return;
}
if let Callee::Expr(expr) = &call.callee {
let is_pragma = match expr.as_ref() {
Expr::Ident(id) => is_jsx_pragma_name(id.sym.as_ref()),
Expr::Member(m) => {
if let MemberProp::Ident(prop) = &m.prop {
is_jsx_pragma_name(prop.sym.as_ref())
&& !(prop.sym.as_ref() == CLASSIC_PRAGMA
&& matches!(m.obj.as_ref(), Expr::Ident(obj) if obj.sym.as_ref() == "document"))
} else {
false
}
}
_ => false,
};
if is_pragma {
self.found = true;
return;
}
}
call.visit_children_with(self);
}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if self.found {
return;
}
if let swc_core::ecma::ast::AssignTarget::Simple(
swc_core::ecma::ast::SimpleAssignTarget::Member(member),
) = &assign.left
{
if let MemberProp::Ident(prop) = &member.prop {
if prop.sym.as_ref() == "displayName" {
self.found = true;
return;
}
}
}
assign.visit_children_with(self);
}
}
let mut scan = Scan { found: false };
module.visit_with(&mut scan);
scan.found
}
fn process_module_items(&mut self, items: &mut Vec<ModuleItem>) {
self.converted_classic_pragma = false;
self.import_pragmas = collect_import_pragmas(items);
let (renames, name_registry) =
collect_module_renames(items, self.unresolved_mark, &self.import_pragmas);
if !renames.is_empty() {
let mut renamer = ScopedRenamer::new(renames);
for item in items.iter_mut() {
item.visit_mut_with(&mut renamer);
}
}
self.used_names.push(name_registry);
self.string_consts
.push(collect_string_consts_from_module_items(items));
let old = std::mem::take(items);
let mut rewritten = Vec::with_capacity(old.len());
for mut item in old {
self.pending_stmts.push(Vec::new());
item.visit_mut_with(self);
let pending = self.pending_stmts.pop().unwrap();
rewritten.extend(pending.into_iter().map(ModuleItem::Stmt));
rewritten.push(item);
}
self.string_consts.pop();
self.used_names.pop();
*items = rewritten;
if self.converted_classic_pragma {
strip_unused_classic_pragma_imports(items);
}
}
fn process_stmts(&mut self, stmts: &mut Vec<Stmt>) {
let (renames, name_registry) =
collect_stmt_renames(stmts, self.unresolved_mark, &self.import_pragmas);
if !renames.is_empty() {
let mut renamer = ScopedRenamer::new(renames);
for stmt in stmts.iter_mut() {
stmt.visit_mut_with(&mut renamer);
}
}
self.used_names.push(name_registry);
self.string_consts
.push(collect_string_consts_from_stmts(stmts));
let old = std::mem::take(stmts);
let mut rewritten = Vec::with_capacity(old.len());
for mut stmt in old {
self.pending_stmts.push(Vec::new());
stmt.visit_mut_with(self);
let pending = self.pending_stmts.pop().unwrap();
rewritten.extend(pending);
rewritten.push(stmt);
}
self.string_consts.pop();
self.used_names.pop();
*stmts = rewritten;
}
fn convert_call(&mut self, call: &CallExpr) -> Option<Expr> {
let pragma = get_pragma(&call.callee, &self.import_pragmas)?;
if call.args.len() < 2 {
return None;
}
let type_arg = &call.args[0];
if type_arg.spread.is_some() {
return None;
}
let type_expr = type_arg.expr.as_ref();
if is_capitalization_invalid(type_expr) {
return None;
}
let mut tag = self.to_jsx_element_name(type_expr);
if let Some(inlined) = self.inline_const_string_tag(type_expr) {
tag = self.to_jsx_element_name(&Expr::Lit(Lit::Str(inlined)));
}
if tag.is_none() {
let should_alias = self.level >= RewriteLevel::Aggressive
|| (self.level >= RewriteLevel::Standard
&& self.has_strong_jsx_shape(pragma, call));
if should_alias {
let base = if expr_contains_inlined_jsx_component(type_expr) {
"InlineComponent"
} else {
"Component"
};
let alias = self.create_component_alias(type_expr, base);
tag = Some(JSXElementName::Ident(alias));
}
}
let tag = tag?;
let mut attrs = self.to_jsx_attrs(&call.args[1])?;
let automatic = is_automatic_pragma(pragma);
let mut children = if automatic {
let extracted = extract_children_attr(&mut attrs)
.into_iter()
.flat_map(|value| self.jsx_attr_value_to_children(value))
.collect::<Vec<_>>();
if call.args.len() >= 3 {
let key_arg = &call.args[2];
if key_arg.spread.is_none() && !is_undefined_expr(&key_arg.expr) {
attrs.insert(
0,
JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name: JSXAttrName::Ident("key".into()),
value: Some(self.expr_to_attr_value(key_arg.expr.as_ref())),
}),
);
}
}
extracted
} else {
call.args[2..]
.iter()
.filter_map(|arg| self.expr_or_spread_to_child(arg))
.collect::<Vec<_>>()
};
if is_fragment_name(&tag) && attrs.is_empty() {
if pragma == CLASSIC_PRAGMA {
self.converted_classic_pragma = true;
}
let outer_span = if call.span.lo.0 != 0 {
call.span
} else {
DUMMY_SP
};
return Some(Expr::JSXFragment(JSXFragment {
span: outer_span,
opening: JSXOpeningFragment { span: DUMMY_SP },
children,
closing: JSXClosingFragment { span: DUMMY_SP },
}));
}
let self_closing = children.is_empty();
let closing = (!self_closing).then_some(JSXClosingElement {
span: DUMMY_SP,
name: tag.clone(),
});
if pragma == CLASSIC_PRAGMA {
self.converted_classic_pragma = true;
}
let outer_span = if call.span.lo.0 != 0 {
call.span
} else {
DUMMY_SP
};
Some(Expr::JSXElement(Box::new(JSXElement {
span: outer_span,
opening: JSXOpeningElement {
name: tag,
span: DUMMY_SP,
attrs,
self_closing,
type_args: None,
},
children: std::mem::take(&mut children),
closing,
})))
}
fn inline_const_string_tag(&self, expr: &Expr) -> Option<Str> {
let Expr::Ident(ident) = expr else {
return None;
};
let id = (ident.sym.clone(), ident.ctxt);
for scope in self.string_consts.iter().rev() {
if let Some(value) = scope.get(&id) {
return Some(value.clone());
}
}
None
}
fn create_component_alias(&mut self, expr: &Expr, base: &str) -> Ident {
let name = self.generate_name(base.to_string());
let ident = Ident::new(name.clone().into(), DUMMY_SP, SyntaxContext::empty());
if let Some(pending) = self.pending_stmts.last_mut() {
pending.push(Stmt::Decl(Decl::Var(Box::new(VarDecl {
span: DUMMY_SP,
ctxt: SyntaxContext::empty(),
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(BindingIdent {
id: ident.clone(),
type_ann: None,
}),
init: Some(Box::new(expr.clone())),
definite: false,
}],
}))));
}
ident
}
fn generate_name(&mut self, base: String) -> String {
let names = self.used_names.last_mut().expect("body scope should exist");
let base_atom = Atom::from(base.as_str());
if !names.contains(&base_atom) {
names.insert(base_atom);
return base;
}
let mut idx = 1usize;
loop {
let candidate = format!("{base}_{idx}");
let candidate_atom = Atom::from(candidate.as_str());
if !names.contains(&candidate_atom) {
names.insert(candidate_atom);
return candidate;
}
idx += 1;
}
}
fn to_jsx_element_name(&self, expr: &Expr) -> Option<JSXElementName> {
match expr {
Expr::Lit(Lit::Str(s)) => jsx_name_from_string(s),
Expr::Ident(ident) => Some(JSXElementName::Ident(ident.clone())),
Expr::Member(member) => self.member_expr_to_jsx_name(member),
_ => None,
}
}
fn member_expr_to_jsx_name(&self, member: &MemberExpr) -> Option<JSXElementName> {
let prop = match &member.prop {
MemberProp::Ident(ident) => ident.clone(),
_ => return None,
};
let obj = self.expr_to_jsx_object(&member.obj)?;
Some(JSXElementName::JSXMemberExpr(JSXMemberExpr {
span: DUMMY_SP,
obj,
prop,
}))
}
fn expr_to_jsx_object(&self, expr: &Expr) -> Option<JSXObject> {
match expr {
Expr::Ident(ident) => Some(JSXObject::Ident(ident.clone())),
Expr::Member(member) => {
let prop = match &member.prop {
MemberProp::Ident(ident) => ident.clone(),
_ => return None,
};
let obj = self.expr_to_jsx_object(&member.obj)?;
Some(JSXObject::JSXMemberExpr(Box::new(JSXMemberExpr {
span: DUMMY_SP,
obj,
prop,
})))
}
_ => None,
}
}
fn to_jsx_attrs(&self, props_arg: &ExprOrSpread) -> Option<Vec<JSXAttrOrSpread>> {
if props_arg.spread.is_some() {
return self.to_jsx_attrs_from_expr(props_arg.expr.as_ref());
}
self.to_jsx_attrs_from_expr(props_arg.expr.as_ref())
}
fn to_jsx_attrs_from_expr(&self, expr: &Expr) -> Option<Vec<JSXAttrOrSpread>> {
match expr {
Expr::Lit(Lit::Null(_)) => Some(Vec::new()),
Expr::Call(call) if is_react_spread(call) || is_object_assign(call) => {
let mut attrs = Vec::new();
for arg in &call.args {
attrs.extend(self.to_jsx_attrs(arg)?);
}
Some(attrs)
}
Expr::Object(obj) => Some(self.object_lit_to_jsx_attrs(obj)),
_ => Some(vec![JSXAttrOrSpread::SpreadElement(SpreadElement {
dot3_token: DUMMY_SP,
expr: Box::new(expr.clone()),
})]),
}
}
fn object_lit_to_jsx_attrs(&self, obj: &ObjectLit) -> Vec<JSXAttrOrSpread> {
let mut attrs = Vec::new();
for prop in &obj.props {
match prop {
PropOrSpread::Spread(spread) => {
attrs.push(JSXAttrOrSpread::SpreadElement(SpreadElement {
dot3_token: DUMMY_SP,
expr: spread.expr.clone(),
}));
}
PropOrSpread::Prop(prop) => {
if let Some(attr) = self.prop_to_jsx_attr(prop.as_ref()) {
attrs.push(attr);
}
}
}
}
attrs
}
fn prop_to_jsx_attr(&self, prop: &Prop) -> Option<JSXAttrOrSpread> {
match prop {
Prop::KeyValue(KeyValueProp { key, value }) => {
if is_computed_prop_name(key) {
return Some(wrap_prop_as_spread(prop.clone()));
}
let name = prop_name_to_attr_name(key)?;
if is_true_expr(value) {
return Some(JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name,
value: None,
}));
}
Some(JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name,
value: Some(self.expr_to_attr_value(value)),
}))
}
Prop::Shorthand(ident) => Some(JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name: prop_name_to_attr_name(&PropName::Ident(ident.clone().into()))?,
value: Some(JSXAttrValue::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(Expr::Ident(ident.clone()))),
})),
})),
Prop::Method(method) => {
if is_computed_prop_name(&method.key) {
return Some(wrap_prop_as_spread(prop.clone()));
}
let name = prop_name_to_attr_name(&method.key)?;
let value = Expr::Fn(swc_core::ecma::ast::FnExpr {
ident: None,
function: method.function.clone(),
});
Some(JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name,
value: Some(self.expr_to_attr_value(&value)),
}))
}
_ => Some(wrap_prop_as_spread(prop.clone())),
}
}
fn expr_to_attr_value(&self, expr: &Expr) -> JSXAttrValue {
match expr {
Expr::Lit(Lit::Str(s)) if can_string_be_attr_literal(s) => JSXAttrValue::Str(s.clone()),
Expr::JSXElement(el) => JSXAttrValue::JSXElement(el.clone()),
Expr::JSXFragment(fragment) => JSXAttrValue::JSXFragment(fragment.clone()),
_ => JSXAttrValue::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(expr.clone())),
}),
}
}
fn jsx_attr_value_to_children(&self, value: JSXAttrValue) -> Vec<JSXElementChild> {
match value {
JSXAttrValue::Str(s) => self
.expr_to_child(&Expr::Lit(Lit::Str(s)))
.into_iter()
.collect(),
JSXAttrValue::JSXExprContainer(container) => match container.expr {
JSXExpr::Expr(expr) => {
if let Expr::Array(array) = expr.as_ref() {
array
.elems
.iter()
.filter_map(|elem| elem.as_ref())
.filter_map(|elem| self.expr_or_spread_to_child(elem))
.collect()
} else {
self.expr_to_child(expr.as_ref()).into_iter().collect()
}
}
JSXExpr::JSXEmptyExpr(_) => Vec::new(),
},
JSXAttrValue::JSXElement(el) => vec![JSXElementChild::JSXElement(el)],
JSXAttrValue::JSXFragment(fragment) => vec![JSXElementChild::JSXFragment(fragment)],
}
}
fn expr_or_spread_to_child(&self, arg: &ExprOrSpread) -> Option<JSXElementChild> {
if arg.spread.is_some() {
return Some(JSXElementChild::JSXSpreadChild(JSXSpreadChild {
span: DUMMY_SP,
expr: arg.expr.clone(),
}));
}
self.expr_to_child(arg.expr.as_ref())
}
fn expr_to_child(&self, expr: &Expr) -> Option<JSXElementChild> {
match expr {
Expr::JSXElement(el) => Some(JSXElementChild::JSXElement(el.clone())),
Expr::JSXFragment(fragment) => Some(JSXElementChild::JSXFragment(fragment.clone())),
Expr::Lit(Lit::Null(_)) => None,
Expr::Lit(Lit::Bool(_)) => None,
e if is_undefined_expr_boxed(e) => None,
Expr::Lit(Lit::Str(s)) => string_child(s),
_ => Some(JSXElementChild::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(expr.clone())),
})),
}
}
fn has_strong_jsx_shape(&self, pragma: &str, call: &CallExpr) -> bool {
if call.args.len() < 2 {
return false;
}
if expr_contains_inlined_jsx_component(call.args[0].expr.as_ref()) {
return true;
}
let props_expr = call.args[1].expr.as_ref();
if !expr_has_jsxish_props(props_expr) {
return false;
}
is_automatic_pragma(pragma) || is_jsxish_props_container(props_expr)
}
}
impl VisitMut for UnJsx {
fn visit_mut_module(&mut self, module: &mut Module) {
if self.level < RewriteLevel::Standard || !Self::should_run(module) {
return;
}
self.process_module_items(&mut module.body);
}
fn visit_mut_block_stmt(&mut self, block: &mut BlockStmt) {
if self.level < RewriteLevel::Standard {
return;
}
if stmts_have_jsx_content(&block.stmts, &self.import_pragmas) {
self.process_stmts(&mut block.stmts);
} else {
block.visit_mut_children_with(self);
}
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if self.level < RewriteLevel::Standard {
return;
}
expr.visit_mut_children_with(self);
let replacement = match expr {
Expr::Call(call) => self.convert_call(call),
_ => None,
};
if let Some(replacement) = replacement {
*expr = replacement;
}
}
}
impl Rule for UnJsx {
fn name(&self) -> &'static str {
"un-jsx"
}
}
fn stmts_have_jsx_content(
stmts: &[Stmt],
import_pragmas: &HashMap<BindingId, &'static str>,
) -> bool {
struct BlockScan<'a> {
found: bool,
import_pragmas: &'a HashMap<BindingId, &'static str>,
}
impl Visit for BlockScan<'_> {
fn visit_call_expr(&mut self, call: &CallExpr) {
if self.found {
return;
}
if let Callee::Expr(expr) = &call.callee {
let is_pragma = match expr.as_ref() {
Expr::Ident(id) => {
is_jsx_pragma_name(id.sym.as_ref())
|| self.import_pragmas.contains_key(&(id.sym.clone(), id.ctxt))
}
Expr::Member(m) => {
matches!(&m.prop, MemberProp::Ident(p) if is_jsx_pragma_name(p.sym.as_ref())
&& !(p.sym.as_ref() == CLASSIC_PRAGMA
&& matches!(m.obj.as_ref(), Expr::Ident(obj) if obj.sym.as_ref() == "document")))
}
_ => false,
};
if is_pragma {
self.found = true;
return;
}
}
call.visit_children_with(self);
}
fn visit_assign_expr(&mut self, assign: &AssignExpr) {
if self.found {
return;
}
if let swc_core::ecma::ast::AssignTarget::Simple(
swc_core::ecma::ast::SimpleAssignTarget::Member(member),
) = &assign.left
{
if let MemberProp::Ident(prop) = &member.prop {
if prop.sym.as_ref() == "displayName" {
if let Expr::Ident(obj) = member.obj.as_ref() {
if obj.sym.len() <= 2 {
self.found = true;
return;
}
}
}
}
}
assign.visit_children_with(self);
}
}
let mut scan = BlockScan {
found: false,
import_pragmas,
};
stmts.visit_with(&mut scan);
scan.found
}
#[derive(Default)]
struct NameCollector {
names: HashSet<Atom>,
}
impl Visit for NameCollector {
fn visit_ident(&mut self, ident: &Ident) {
self.names.insert(ident.sym.clone());
}
fn visit_binding_ident(&mut self, ident: &BindingIdent) {
self.names.insert(ident.id.sym.clone());
}
}
fn strip_unused_classic_pragma_imports(items: &mut [ModuleItem]) {
let referenced = BindingUseIndex::collect_module_items(items).referenced_bindings();
for item in items {
let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
continue;
};
import.specifiers.retain(|spec| match spec {
ImportSpecifier::Default(default) if default.local.sym == *CLASSIC_PRAGMA => {
referenced.contains(&(default.local.sym.clone(), default.local.ctxt))
}
ImportSpecifier::Named(named) if named.local.sym == *CLASSIC_PRAGMA => {
referenced.contains(&(named.local.sym.clone(), named.local.ctxt))
}
_ => true,
});
}
}
#[derive(Default)]
struct ConstStringCollector {
values: HashMap<BindingId, Str>,
}
impl Visit for ConstStringCollector {
fn visit_var_decl(&mut self, var_decl: &VarDecl) {
if var_decl.kind != VarDeclKind::Const {
return;
}
for decl in &var_decl.decls {
let Pat::Ident(binding) = &decl.name else {
continue;
};
let Some(init) = &decl.init else {
continue;
};
let Expr::Lit(Lit::Str(value)) = init.as_ref() else {
continue;
};
self.values
.insert((binding.id.sym.clone(), binding.id.ctxt), value.clone());
}
}
}
fn collect_names_in_module_items(items: &[ModuleItem]) -> HashSet<Atom> {
let mut collector = NameCollector::default();
items.visit_with(&mut collector);
collector.names
}
fn collect_names_in_stmts(stmts: &[Stmt]) -> HashSet<Atom> {
let mut collector = NameCollector::default();
stmts.visit_with(&mut collector);
collector.names
}
fn collect_string_consts_from_module_items(items: &[ModuleItem]) -> HashMap<BindingId, Str> {
let mut collector = ConstStringCollector::default();
items.visit_with(&mut collector);
collector.values
}
fn collect_string_consts_from_stmts(stmts: &[Stmt]) -> HashMap<BindingId, Str> {
let mut collector = ConstStringCollector::default();
stmts.visit_with(&mut collector);
collector.values
}
fn collect_import_pragmas(items: &[ModuleItem]) -> HashMap<BindingId, &'static str> {
let mut map = HashMap::new();
for item in items {
let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
continue;
};
let src = wtf8_to_string(&import.src.value);
if !matches!(src.as_str(), "react/jsx-runtime" | "react/jsx-dev-runtime") {
continue;
}
for spec in &import.specifiers {
let ImportSpecifier::Named(named) = spec else {
continue;
};
let imported_name = match &named.imported {
Some(ModuleExportName::Ident(id)) => id.sym.to_string(),
Some(ModuleExportName::Str(s)) => wtf8_to_string(&s.value),
None => continue,
};
let pragma: Option<&'static str> = match imported_name.as_str() {
"jsx" => Some("jsx"),
"jsxs" => Some("jsxs"),
"jsxDEV" => Some("jsxDEV"),
"jsxsDEV" => Some("jsxsDEV"),
_ => None,
};
if let Some(pragma) = pragma {
map.insert((named.local.sym.clone(), named.local.ctxt), pragma);
}
}
}
map
}
fn has_display_name_candidates<'a>(stmts: impl Iterator<Item = &'a Stmt>) -> bool {
stmts.into_iter().any(|stmt| {
let Stmt::Expr(expr_stmt) = stmt else {
return false;
};
let Expr::Assign(assign) = expr_stmt.expr.as_ref() else {
return false;
};
if assign.op != AssignOp::Assign {
return false;
}
let swc_core::ecma::ast::AssignTarget::Simple(
swc_core::ecma::ast::SimpleAssignTarget::Member(member),
) = &assign.left
else {
return false;
};
matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "displayName")
&& matches!(member.obj.as_ref(), Expr::Ident(obj) if obj.sym.len() <= 2)
})
}
fn has_lowercase_jsx_component_calls(
items: &[ModuleItem],
import_pragmas: &HashMap<BindingId, &'static str>,
unresolved_mark: Mark,
) -> bool {
struct Scan<'a> {
found: bool,
import_pragmas: &'a HashMap<BindingId, &'static str>,
unresolved_mark: Mark,
}
impl Visit for Scan<'_> {
fn visit_call_expr(&mut self, call: &CallExpr) {
if self.found {
return;
}
if get_pragma(&call.callee, self.import_pragmas).is_some() {
if let Some(first) = call.args.first() {
if first.spread.is_none() {
if let Expr::Ident(id) = first.expr.as_ref() {
if starts_with_lowercase(id.sym.as_ref())
&& id.ctxt.outer() != self.unresolved_mark
{
self.found = true;
return;
}
}
}
}
}
call.visit_children_with(self);
}
}
let mut scan = Scan {
found: false,
import_pragmas,
unresolved_mark,
};
items.visit_with(&mut scan);
scan.found
}
fn has_lowercase_jsx_component_calls_stmts(
stmts: &[Stmt],
import_pragmas: &HashMap<BindingId, &'static str>,
unresolved_mark: Mark,
) -> bool {
struct Scan<'a> {
found: bool,
import_pragmas: &'a HashMap<BindingId, &'static str>,
unresolved_mark: Mark,
}
impl Visit for Scan<'_> {
fn visit_call_expr(&mut self, call: &CallExpr) {
if self.found {
return;
}
if get_pragma(&call.callee, self.import_pragmas).is_some() {
if let Some(first) = call.args.first() {
if first.spread.is_none() {
if let Expr::Ident(id) = first.expr.as_ref() {
if starts_with_lowercase(id.sym.as_ref())
&& id.ctxt.outer() != self.unresolved_mark
{
self.found = true;
return;
}
}
}
}
}
call.visit_children_with(self);
}
}
let mut scan = Scan {
found: false,
import_pragmas,
unresolved_mark,
};
stmts.visit_with(&mut scan);
scan.found
}
fn collect_module_renames(
items: &[ModuleItem],
unresolved_mark: Mark,
import_pragmas: &HashMap<BindingId, &'static str>,
) -> (Vec<ScopedRename>, HashSet<Atom>) {
let has_display = has_display_name_candidates(items.iter().filter_map(|i| {
if let ModuleItem::Stmt(s) = i {
Some(s)
} else {
None
}
}));
let has_lc = has_lowercase_jsx_component_calls(items, import_pragmas, unresolved_mark);
if !has_display && !has_lc {
return (Vec::new(), collect_names_in_module_items(items));
}
let mut name_registry = collect_names_in_module_items(items);
let mut renames = if has_display {
collect_display_name_renames_from_module_items(items, &mut name_registry)
} else {
Vec::new()
};
if has_lc {
renames.extend(collect_lowercase_component_renames_from_module_items(
items,
unresolved_mark,
&mut name_registry,
import_pragmas,
));
}
(renames, name_registry)
}
fn collect_stmt_renames(
stmts: &[Stmt],
unresolved_mark: Mark,
import_pragmas: &HashMap<BindingId, &'static str>,
) -> (Vec<ScopedRename>, HashSet<Atom>) {
let has_display = has_display_name_candidates(stmts.iter());
let has_lc = has_lowercase_jsx_component_calls_stmts(stmts, import_pragmas, unresolved_mark);
if !has_display && !has_lc {
return (Vec::new(), collect_names_in_stmts(stmts));
}
let mut name_registry = collect_names_in_stmts(stmts);
let mut renames = if has_display {
collect_display_name_renames_from_stmts(stmts, &mut name_registry)
} else {
Vec::new()
};
if has_lc {
renames.extend(collect_lowercase_component_renames_from_stmts(
stmts,
unresolved_mark,
&mut name_registry,
import_pragmas,
));
}
(renames, name_registry)
}
fn collect_display_name_renames_from_module_items(
items: &[ModuleItem],
used_names: &mut HashSet<Atom>,
) -> Vec<ScopedRename> {
let mut renames = Vec::new();
for item in items {
let ModuleItem::Stmt(stmt) = item else {
continue;
};
collect_display_name_renames_from_stmt(stmt, used_names, &mut renames);
}
renames
}
fn collect_display_name_renames_from_stmts(
stmts: &[Stmt],
used_names: &mut HashSet<Atom>,
) -> Vec<ScopedRename> {
let mut renames = Vec::new();
for stmt in stmts {
collect_display_name_renames_from_stmt(stmt, used_names, &mut renames);
}
renames
}
fn collect_display_name_renames_from_stmt(
stmt: &Stmt,
used_names: &mut HashSet<Atom>,
renames: &mut Vec<ScopedRename>,
) {
let Stmt::Expr(expr_stmt) = stmt else {
return;
};
let Expr::Assign(AssignExpr {
op: AssignOp::Assign,
left,
right,
..
}) = expr_stmt.expr.as_ref()
else {
return;
};
let swc_core::ecma::ast::AssignTarget::Simple(simple) = left else {
return;
};
let swc_core::ecma::ast::SimpleAssignTarget::Member(member) = simple else {
return;
};
let Expr::Ident(object) = member.obj.as_ref() else {
return;
};
let MemberProp::Ident(prop) = &member.prop else {
return;
};
if prop.sym != *"displayName" || object.sym.len() > 2 {
return;
}
let Expr::Lit(Lit::Str(display_name)) = right.as_ref() else {
return;
};
let new_name =
generate_unique_name(used_names, pascalize(&wtf8_to_string(&display_name.value)));
renames.push(ScopedRename {
old: (object.sym.clone(), object.ctxt),
new: new_name.into(),
});
}
fn collect_lowercase_component_renames_from_module_items(
items: &[ModuleItem],
unresolved_mark: Mark,
used_names: &mut HashSet<Atom>,
import_pragmas: &HashMap<BindingId, &'static str>,
) -> Vec<ScopedRename> {
let eligible_bindings = collect_eligible_component_bindings_from_module_items(items);
let mut visitor = LowercaseComponentRenameCollector {
unresolved_mark,
used_names,
eligible_bindings,
import_pragmas,
renames: Vec::new(),
};
items.visit_with(&mut visitor);
visitor.renames
}
fn collect_lowercase_component_renames_from_stmts(
stmts: &[Stmt],
unresolved_mark: Mark,
used_names: &mut HashSet<Atom>,
import_pragmas: &HashMap<BindingId, &'static str>,
) -> Vec<ScopedRename> {
let eligible_bindings = collect_eligible_component_bindings_from_stmts(stmts);
let mut visitor = LowercaseComponentRenameCollector {
unresolved_mark,
used_names,
eligible_bindings,
import_pragmas,
renames: Vec::new(),
};
stmts.visit_with(&mut visitor);
visitor.renames
}
struct LowercaseComponentRenameCollector<'a> {
unresolved_mark: Mark,
used_names: &'a mut HashSet<Atom>,
eligible_bindings: HashMap<BindingId, ComponentBindingEligibility>,
import_pragmas: &'a HashMap<BindingId, &'static str>,
renames: Vec<ScopedRename>,
}
impl Visit for LowercaseComponentRenameCollector<'_> {
fn visit_call_expr(&mut self, call: &CallExpr) {
let Some(pragma) = get_pragma(&call.callee, self.import_pragmas) else {
call.visit_children_with(self);
return;
};
if let Some(first) = call.args.first() {
if first.spread.is_none() {
if let Expr::Ident(ident) = first.expr.as_ref() {
if starts_with_lowercase(ident.sym.as_ref())
&& ident.ctxt.outer() != self.unresolved_mark
{
let binding_id = (ident.sym.clone(), ident.ctxt);
if let Some(eligibility) = self.eligible_bindings.get(&binding_id) {
let can_rename = eligibility.allow_classic_create_element
|| is_automatic_pragma(pragma);
if can_rename {
let target_name = eligibility
.hint
.clone()
.unwrap_or_else(|| pascalize(ident.sym.as_ref()));
let new_name = generate_unique_name(self.used_names, target_name);
self.renames.push(ScopedRename {
old: binding_id,
new: new_name.into(),
});
}
}
}
}
}
}
call.visit_children_with(self);
}
}
struct ScopedRenamer {
renames: Vec<ScopedRename>,
}
impl ScopedRenamer {
fn new(renames: Vec<ScopedRename>) -> Self {
Self { renames }
}
}
impl VisitMut for ScopedRenamer {
fn visit_mut_ident(&mut self, ident: &mut Ident) {
for rename in &self.renames {
if ident.sym == rename.old.0 && ident.ctxt == rename.old.1 {
ident.sym = rename.new.clone();
break;
}
}
}
}
#[derive(Default)]
struct EligibleComponentBindingCollector {
bindings: HashMap<BindingId, ComponentBindingEligibility>,
include_all_const_bindings: bool,
}
#[derive(Clone)]
struct ComponentBindingEligibility {
hint: Option<String>,
allow_classic_create_element: bool,
}
impl Visit for EligibleComponentBindingCollector {
fn visit_fn_decl(&mut self, decl: &swc_core::ecma::ast::FnDecl) {
self.record(&decl.ident, None, true);
}
fn visit_class_decl(&mut self, decl: &swc_core::ecma::ast::ClassDecl) {
self.record(&decl.ident, None, true);
}
fn visit_import_decl(&mut self, decl: &ImportDecl) {
for specifier in &decl.specifiers {
match specifier {
ImportSpecifier::Named(named) => {
self.record(&named.local, None, true);
}
ImportSpecifier::Default(default) => {
self.record(&default.local, None, true);
}
ImportSpecifier::Namespace(namespace) => {
self.record(&namespace.local, None, true);
}
}
}
}
fn visit_var_decl(&mut self, decl: &VarDecl) {
if !matches!(decl.kind, VarDeclKind::Const | VarDeclKind::Var) {
return;
}
for declarator in &decl.decls {
if self.include_all_const_bindings {
self.add_pat(&declarator.name, decl.kind == VarDeclKind::Const);
continue;
}
if declarator.init.is_some() {
if let Pat::Ident(binding) = &declarator.name {
let init = declarator.init.as_deref().expect("checked above");
let is_const = decl.kind == VarDeclKind::Const;
if !is_const && !is_likely_var_component_initializer(init) {
continue;
}
let hint = component_name_hint_from_expr(init);
self.record(&binding.id, hint, is_const);
} else {
self.add_pat(&declarator.name, decl.kind == VarDeclKind::Const);
}
}
}
}
fn visit_function(&mut self, function: &swc_core::ecma::ast::Function) {
for param in &function.params {
self.add_param(param);
}
function.visit_children_with(self);
}
fn visit_arrow_expr(&mut self, arrow: &ArrowExpr) {
for param in &arrow.params {
self.add_pat(param, true);
}
arrow.visit_children_with(self);
}
}
impl EligibleComponentBindingCollector {
fn record(&mut self, ident: &Ident, hint: Option<String>, allow_classic_create_element: bool) {
self.bindings.insert(
(ident.sym.clone(), ident.ctxt),
ComponentBindingEligibility {
hint,
allow_classic_create_element,
},
);
}
fn add_param(&mut self, param: &Param) {
self.add_pat(¶m.pat, true);
}
fn add_pat(&mut self, pat: &Pat, allow_classic_create_element: bool) {
match pat {
Pat::Ident(binding) => {
self.record(&binding.id, None, allow_classic_create_element);
}
Pat::Array(array) => {
for elem in array.elems.iter().flatten() {
self.add_pat(elem, allow_classic_create_element);
}
}
Pat::Object(object) => {
for prop in &object.props {
match prop {
swc_core::ecma::ast::ObjectPatProp::Assign(assign) => {
self.record(&assign.key, None, allow_classic_create_element);
}
swc_core::ecma::ast::ObjectPatProp::KeyValue(key_value) => {
self.add_pat(&key_value.value, allow_classic_create_element);
}
swc_core::ecma::ast::ObjectPatProp::Rest(rest) => {
self.add_pat(&rest.arg, allow_classic_create_element);
}
}
}
}
Pat::Assign(assign) => self.add_pat(&assign.left, allow_classic_create_element),
Pat::Rest(rest) => self.add_pat(&rest.arg, allow_classic_create_element),
_ => {}
}
}
}
fn collect_eligible_component_bindings_from_module_items(
items: &[ModuleItem],
) -> HashMap<BindingId, ComponentBindingEligibility> {
let mut collector = EligibleComponentBindingCollector::default();
items.visit_with(&mut collector);
collector.bindings
}
fn collect_eligible_component_bindings_from_stmts(
stmts: &[Stmt],
) -> HashMap<BindingId, ComponentBindingEligibility> {
let mut collector = EligibleComponentBindingCollector::default();
stmts.visit_with(&mut collector);
collector.bindings
}
fn component_name_hint_from_expr(expr: &Expr) -> Option<String> {
let Expr::Member(member) = expr else {
return None;
};
let MemberProp::Ident(prop) = &member.prop else {
return None;
};
let name = prop.sym.as_ref();
starts_with_lowercase(name).then(|| pascalize(name))
}
fn is_likely_var_component_initializer(expr: &Expr) -> bool {
match expr {
Expr::Arrow(_) | Expr::Call(_) | Expr::Class(_) | Expr::Fn(_) | Expr::New(_) => true,
Expr::Paren(paren) => is_likely_var_component_initializer(&paren.expr),
Expr::Seq(seq) => seq
.exprs
.last()
.is_some_and(|expr| is_likely_var_component_initializer(expr)),
_ => false,
}
}
fn get_pragma(
callee: &Callee,
import_pragmas: &HashMap<BindingId, &'static str>,
) -> Option<&'static str> {
let Callee::Expr(expr) = callee else {
return None;
};
match expr.as_ref() {
Expr::Ident(ident) => {
if let Some(pragma) = import_pragmas.get(&(ident.sym.clone(), ident.ctxt)) {
return Some(*pragma);
}
match ident.sym.as_ref() {
CLASSIC_PRAGMA => Some(CLASSIC_PRAGMA),
"jsx" => Some("jsx"),
"jsxs" => Some("jsxs"),
"_jsx" => Some("_jsx"),
"_jsxs" => Some("_jsxs"),
"jsxDEV" => Some("jsxDEV"),
"jsxsDEV" => Some("jsxsDEV"),
_ => None,
}
}
Expr::Member(member) => {
let Expr::Ident(object) = member.obj.as_ref() else {
return None;
};
let MemberProp::Ident(prop) = &member.prop else {
return None;
};
if object.sym == *"document" && prop.sym == *"createElement" {
return None;
}
match prop.sym.as_ref() {
CLASSIC_PRAGMA => Some(CLASSIC_PRAGMA),
"jsx" => Some("jsx"),
"jsxs" => Some("jsxs"),
"jsxDEV" => Some("jsxDEV"),
"jsxsDEV" => Some("jsxsDEV"),
_ => None,
}
}
_ => None,
}
}
fn is_capitalization_invalid(expr: &Expr) -> bool {
match expr {
Expr::Lit(Lit::Str(s)) => !starts_with_lowercase(&wtf8_to_string(&s.value)),
Expr::Ident(ident) => starts_with_lowercase(ident.sym.as_ref()),
_ => false,
}
}
fn starts_with_lowercase(value: &str) -> bool {
value
.chars()
.next()
.map(|ch| ch.is_ascii_lowercase())
.unwrap_or(false)
}
fn jsx_name_from_string(value: &Str) -> Option<JSXElementName> {
let value_string = wtf8_to_string(&value.value);
if let Some((ns, name)) = value_string.split_once(':') {
return Some(JSXElementName::JSXNamespacedName(JSXNamespacedName {
span: DUMMY_SP,
ns: ns.into(),
name: name.into(),
}));
}
Some(JSXElementName::Ident(Ident::new(
value_string.into(),
DUMMY_SP,
SyntaxContext::empty(),
)))
}
fn prop_name_to_attr_name(name: &PropName) -> Option<JSXAttrName> {
match name {
PropName::Ident(ident) => Some(JSXAttrName::Ident(ident.clone())),
PropName::Str(str_lit) => {
let value = wtf8_to_string(&str_lit.value);
if let Some((ns, name)) = value.split_once(':') {
Some(JSXAttrName::JSXNamespacedName(JSXNamespacedName {
span: DUMMY_SP,
ns: ns.into(),
name: name.into(),
}))
} else {
Some(JSXAttrName::Ident(value.into()))
}
}
_ => None,
}
}
fn is_fragment_name(name: &JSXElementName) -> bool {
match name {
JSXElementName::Ident(ident) => ident.sym == *"Fragment",
JSXElementName::JSXMemberExpr(member) => member.prop.sym == *"Fragment",
_ => false,
}
}
fn wrap_prop_as_spread(prop: Prop) -> JSXAttrOrSpread {
JSXAttrOrSpread::SpreadElement(SpreadElement {
dot3_token: DUMMY_SP,
expr: Box::new(Expr::Object(ObjectLit {
span: DUMMY_SP,
props: vec![PropOrSpread::Prop(Box::new(prop))],
})),
})
}
fn is_react_spread(call: &CallExpr) -> bool {
let Callee::Expr(expr) = &call.callee else {
return false;
};
let Expr::Member(member) = expr.as_ref() else {
return false;
};
let Expr::Ident(_) = member.obj.as_ref() else {
return false;
};
matches!(&member.prop, MemberProp::Ident(ident) if ident.sym == *"__spread")
}
fn is_object_assign(call: &CallExpr) -> bool {
let Callee::Expr(expr) = &call.callee else {
return false;
};
let Expr::Member(member) = expr.as_ref() else {
return false;
};
let Expr::Ident(object) = member.obj.as_ref() else {
return false;
};
object.sym == *"Object"
&& matches!(&member.prop, MemberProp::Ident(ident) if ident.sym == *"assign")
}
fn is_computed_prop_name(name: &PropName) -> bool {
matches!(name, PropName::Computed(_))
}
fn is_true_expr(expr: &Expr) -> bool {
matches!(expr, Expr::Lit(Lit::Bool(Bool { value: true, .. })))
}
fn can_string_be_attr_literal(value: &Str) -> bool {
let raw = value
.raw
.as_ref()
.map(|raw| raw.as_ref())
.unwrap_or_default();
!raw.contains('\\') && !wtf8_to_string(&value.value).contains('"')
}
fn string_child(value: &Str) -> Option<JSXElementChild> {
let text = wtf8_to_string(&value.value);
if text.is_empty() {
return Some(JSXElementChild::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(Expr::Lit(Lit::Str(value.clone())))),
}));
}
// Only characters that are syntactically invalid inside JSXText need wrapping.
// Leading/trailing whitespace is preserved by JSXText on a single line.
let needs_expr =
text.contains(['{', '}', '<', '>']) || text.contains('\r') || text.contains('\n');
if needs_expr {
return Some(JSXElementChild::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(Expr::Lit(Lit::Str(value.clone())))),
}));
}
Some(JSXElementChild::JSXText(JSXText {
span: DUMMY_SP,
value: text.clone().into(),
raw: text.into(),
}))
}
fn is_undefined_expr(expr: &Box<Expr>) -> bool {
is_undefined_expr_boxed(expr.as_ref())
}
fn is_undefined_expr_boxed(expr: &Expr) -> bool {
matches!(expr, Expr::Ident(ident) if ident.sym == *"undefined")
|| matches!(
expr,
Expr::Unary(unary)
if unary.op == swc_core::ecma::ast::UnaryOp::Void
&& matches!(
unary.arg.as_ref(),
Expr::Lit(Lit::Num(Number { value, .. })) if (*value - 0.0).abs() < f64::EPSILON
)
)
}
fn extract_children_attr(attrs: &mut Vec<JSXAttrOrSpread>) -> Option<JSXAttrValue> {
let idx = attrs.iter().position(|attr| {
matches!(
attr,
JSXAttrOrSpread::JSXAttr(JSXAttr {
name: JSXAttrName::Ident(name),
..
}) if name.sym == *"children"
)
})?;
let JSXAttrOrSpread::JSXAttr(attr) = attrs.remove(idx) else {
return None;
};
attr.value
}
fn expr_has_jsxish_props(expr: &Expr) -> bool {
match expr {
Expr::Object(obj) => object_lit_has_jsxish_props(obj),
Expr::Call(call) if is_react_spread(call) || is_object_assign(call) => call
.args
.iter()
.any(|arg| expr_has_jsxish_props(arg.expr.as_ref())),
_ => false,
}
}
fn is_jsxish_props_container(expr: &Expr) -> bool {
matches!(expr, Expr::Object(_))
|| matches!(expr, Expr::Call(call) if is_react_spread(call) || is_object_assign(call))
}
fn object_lit_has_jsxish_props(obj: &ObjectLit) -> bool {
obj.props.iter().any(|prop| match prop {
PropOrSpread::Spread(spread) => expr_has_jsxish_props(spread.expr.as_ref()),
PropOrSpread::Prop(prop) => prop_has_jsxish_name(prop.as_ref()),
})
}
fn prop_has_jsxish_name(prop: &Prop) -> bool {
match prop {
Prop::KeyValue(KeyValueProp { key, .. }) => prop_name_is_jsxish(key),
Prop::Method(method) => prop_name_is_jsxish(&method.key),
Prop::Shorthand(ident) => is_jsxish_prop_name(ident.sym.as_ref()),
_ => false,
}
}
fn prop_name_is_jsxish(name: &PropName) -> bool {
match name {
PropName::Ident(ident) => is_jsxish_prop_name(ident.sym.as_ref()),
PropName::Str(str_lit) => is_jsxish_prop_name(&wtf8_to_string(&str_lit.value)),
_ => false,
}
}
fn is_jsxish_prop_name(name: &str) -> bool {
matches!(
name,
"children"
| "className"
| "style"
| "ref"
| "key"
| "htmlFor"
| "dangerouslySetInnerHTML"
| "suppressHydrationWarning"
) || name
.strip_prefix("on")
.and_then(|rest| rest.chars().next())
.is_some_and(|ch| ch.is_ascii_uppercase())
}
fn expr_contains_inlined_jsx_component(expr: &Expr) -> bool {
let mut visitor = JsxPresenceVisitor::default();
match expr {
Expr::Arrow(arrow) => arrow.body.visit_with(&mut visitor),
Expr::Fn(function) => {
if let Some(body) = &function.function.body {
body.visit_with(&mut visitor);
}
}
_ => return false,
}
visitor.found
}
#[derive(Default)]
struct JsxPresenceVisitor {
found: bool,
}
impl Visit for JsxPresenceVisitor {
fn visit_jsx_element(&mut self, _element: &JSXElement) {
self.found = true;
}
fn visit_jsx_fragment(&mut self, _fragment: &JSXFragment) {
self.found = true;
}
fn visit_arrow_expr(&mut self, _arrow: &ArrowExpr) {}
fn visit_function(&mut self, _function: &swc_core::ecma::ast::Function) {}
}
fn pascalize(input: &str) -> String {
let mut output = String::new();
let mut capitalize = true;
for ch in input.chars() {
if ch.is_ascii_alphanumeric() {
if capitalize {
output.extend(ch.to_uppercase());
capitalize = false;
} else {
output.push(ch);
}
} else {
capitalize = true;
}
}
if output.is_empty() {
"Component".to_string()
} else {
output
}
}
fn generate_unique_name(used_names: &mut HashSet<Atom>, base: String) -> String {
let base_atom = Atom::from(base.as_str());
if !used_names.contains(&base_atom) {
used_names.insert(base_atom);
return base;
}
let mut idx = 1usize;
loop {
let candidate = format!("{base}{idx}");
let candidate_atom = Atom::from(candidate.as_str());
if !used_names.contains(&candidate_atom) {
used_names.insert(candidate_atom);
return candidate;
}
idx += 1;
}
}
fn wtf8_to_string(value: &Wtf8Atom) -> String {
value
.as_str()
.map(ToOwned::to_owned)
.unwrap_or_else(|| value.to_string_lossy().into_owned())
}