crates/core/src/rules/un_conditionals.rs
GitHubuse std::collections::HashSet;
use swc_core::common::{Span, DUMMY_SP};
use swc_core::ecma::ast::{
BinExpr, BinaryOp, BlockStmt, BreakStmt, CondExpr, Expr, ExprStmt, Ident, IfStmt, Lit,
ModuleItem, ReturnStmt, Stmt, SwitchCase, SwitchStmt, UnaryExpr, UnaryOp,
};
use swc_core::ecma::utils::ExprFactory;
use swc_core::ecma::visit::{VisitMut, VisitMutWith};
use super::decl_utils::same_ident;
use crate::utils::paren::strip_parens_owned;
pub struct UnConditionals;
impl VisitMut for UnConditionals {
fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
items.visit_mut_children_with(self);
let old = std::mem::take(items);
for item in old {
match item {
ModuleItem::Stmt(stmt) => {
let converted = convert_stmt(stmt);
items.extend(converted.into_iter().map(ModuleItem::Stmt));
}
other => items.push(other),
}
}
}
fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
stmts.visit_mut_children_with(self);
let old = std::mem::take(stmts);
for stmt in old {
stmts.extend(convert_stmt(stmt));
}
}
}
pub struct UnConditionalsAssignmentOnly;
impl VisitMut for UnConditionalsAssignmentOnly {
fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
items.visit_mut_children_with(self);
let old = std::mem::take(items);
for item in old {
match item {
ModuleItem::Stmt(stmt) => {
let converted = convert_assignment_only_stmt(stmt);
items.extend(converted.into_iter().map(ModuleItem::Stmt));
}
other => items.push(other),
}
}
}
fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
stmts.visit_mut_children_with(self);
let old = std::mem::take(stmts);
for stmt in old {
stmts.extend(convert_assignment_only_stmt(stmt));
}
}
}
pub struct UnConditionalsExprStmtOnly;
impl VisitMut for UnConditionalsExprStmtOnly {
fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
items.visit_mut_children_with(self);
let old = std::mem::take(items);
for item in old {
match item {
ModuleItem::Stmt(stmt) => {
let converted = convert_cond_expr_stmt_only(stmt);
items.extend(converted.into_iter().map(ModuleItem::Stmt));
}
other => items.push(other),
}
}
}
fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
stmts.visit_mut_children_with(self);
let old = std::mem::take(stmts);
for stmt in old {
stmts.extend(convert_cond_expr_stmt_only(stmt));
}
}
}
/// Convert a single statement, returning one or more statements.
fn convert_stmt(stmt: Stmt) -> Vec<Stmt> {
match stmt {
Stmt::Expr(ExprStmt { expr, span }) => try_convert_expr_stmt_to_if(span, *expr),
Stmt::Return(ReturnStmt {
span,
arg: Some(arg),
}) => {
let is_cond = matches!(*arg, Expr::Cond(_));
if is_cond {
try_split_return_ternary(*arg, span).expect("checked it is Cond above")
} else {
vec![Stmt::Return(ReturnStmt {
span,
arg: Some(arg),
})]
}
}
other => vec![other],
}
}
fn convert_cond_expr_stmt_only(stmt: Stmt) -> Vec<Stmt> {
match stmt {
Stmt::Expr(ExprStmt { expr, span }) if matches!(*expr, Expr::Cond(_)) => {
try_convert_expr_stmt_to_if(span, *expr)
}
other => vec![other],
}
}
fn convert_assignment_only_stmt(stmt: Stmt) -> Vec<Stmt> {
match stmt {
Stmt::Expr(ExprStmt { expr, span }) => try_convert_assignment_only_expr_stmt(span, *expr),
other => vec![other],
}
}
fn try_convert_assignment_only_expr_stmt(span: Span, expr: Expr) -> Vec<Stmt> {
match expr {
Expr::Bin(BinExpr {
op: BinaryOp::LogicalAnd,
left,
right,
..
}) if is_assignment_only_expr(&right) => vec![Stmt::If(IfStmt {
span,
test: left,
cons: Box::new(expr_to_assignment_only_block_stmt(*right)),
alt: None,
})],
Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) if is_assignment_only_expr(&right) => vec![Stmt::If(IfStmt {
span,
test: negate_expr(*left),
cons: Box::new(expr_to_assignment_only_block_stmt(*right)),
alt: None,
})],
other => vec![Stmt::Expr(ExprStmt {
span,
expr: Box::new(other),
})],
}
}
fn is_assignment_only_expr(expr: &Expr) -> bool {
match expr {
Expr::Assign(_) => true,
Expr::Seq(seq) => seq.exprs.iter().all(|expr| is_assignment_only_expr(expr)),
Expr::Paren(paren) => is_assignment_only_expr(&paren.expr),
_ => false,
}
}
fn expr_to_assignment_only_block_stmt(expr: Expr) -> Stmt {
let inner = match expr {
Expr::Paren(paren) => *paren.expr,
other => other,
};
let stmts = match inner {
Expr::Seq(seq) => seq
.exprs
.into_iter()
.flat_map(|expr| {
convert_assignment_only_stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr,
}))
})
.collect(),
other => vec![Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(other),
})],
};
Stmt::Block(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts,
})
}
/// Try to convert an ExprStmt-level expression to an if statement.
/// Returns a Vec<Stmt> which is either the converted if statement(s) or
/// the original ExprStmt wrapped in a Vec.
fn try_convert_expr_stmt_to_if(span: Span, expr: Expr) -> Vec<Stmt> {
match expr {
Expr::Cond(cond_expr) => {
if let Some(switch_stmt) = try_cond_to_switch_expr_stmt(&cond_expr) {
return vec![switch_stmt];
}
// Only convert if at least one branch is action-like (has side effects)
if !is_action_expr(&cond_expr.cons) && !is_action_expr(&cond_expr.alt) {
return vec![Stmt::Expr(ExprStmt {
span,
expr: Box::new(Expr::Cond(cond_expr)),
})];
}
vec![convert_cond_to_if(
span,
*cond_expr.test,
cond_expr.cons,
cond_expr.alt,
)]
}
Expr::Bin(BinExpr {
op: BinaryOp::LogicalAnd,
left,
right,
..
}) => {
// x && action() → if (x) { action(); }
// But only if right-hand side is "action-like" (not a simple value)
if !is_action_expr(&right) {
return vec![Stmt::Expr(ExprStmt {
span,
expr: Box::new((*left).make_bin(BinaryOp::LogicalAnd, *right)),
})];
}
vec![Stmt::If(IfStmt {
span,
test: left,
cons: Box::new(expr_to_block_stmt(*right)),
alt: None,
})]
}
Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) => {
// x || action() → if (!x) { action(); }
if !is_action_expr(&right) {
return vec![Stmt::Expr(ExprStmt {
span,
expr: Box::new((*left).make_bin(BinaryOp::LogicalOr, *right)),
})];
}
vec![Stmt::If(IfStmt {
span,
test: negate_expr(*left),
cons: Box::new(expr_to_block_stmt(*right)),
alt: None,
})]
}
// LogicalNullish (??) - do NOT convert
other => vec![Stmt::Expr(ExprStmt {
span,
expr: Box::new(other),
})],
}
}
/// Check if an expression is "action-like" - has clear side effects worth converting to if/else.
/// Only consider: call expressions, new expressions, assignments, yield, await.
/// Pure reads (identifiers, literals, member access, etc.) are NOT action-like.
fn is_action_expr(expr: &Box<Expr>) -> bool {
match expr.as_ref() {
Expr::Call(_) | Expr::New(_) | Expr::Assign(_) | Expr::Yield(_) | Expr::Await(_) => true,
Expr::Seq(seq) => seq.exprs.iter().any(is_action_expr),
Expr::Paren(paren) => is_action_expr(&paren.expr),
_ => false,
}
}
#[derive(Clone)]
struct SwitchChain {
discriminant: Ident,
cases: Vec<(Box<Expr>, Box<Expr>)>,
default: Box<Expr>,
}
fn try_cond_to_switch_expr_stmt(cond: &CondExpr) -> Option<Stmt> {
let chain = collect_switch_chain(cond)?;
if !chain_has_action(&chain) {
return None;
}
Some(Stmt::Switch(SwitchStmt {
span: DUMMY_SP,
discriminant: Box::new(Expr::Ident(chain.discriminant.clone())),
cases: switch_cases_from_expr_chain(chain),
}))
}
fn try_cond_to_switch_return(cond: &CondExpr, return_span: Span) -> Option<Stmt> {
let chain = collect_switch_chain(cond)?;
let mut cases = Vec::with_capacity(chain.cases.len() + 1);
for (test, body) in chain.cases {
cases.push(SwitchCase {
span: DUMMY_SP,
test: Some(test),
cons: vec![Stmt::Return(ReturnStmt {
span: return_span,
arg: Some(body),
})],
});
}
cases.push(SwitchCase {
span: DUMMY_SP,
test: None,
cons: vec![Stmt::Return(ReturnStmt {
span: return_span,
arg: Some(chain.default),
})],
});
Some(Stmt::Switch(SwitchStmt {
span: DUMMY_SP,
discriminant: Box::new(Expr::Ident(chain.discriminant)),
cases,
}))
}
fn collect_switch_chain(cond: &CondExpr) -> Option<SwitchChain> {
let mut discriminant = None;
let mut cases = Vec::new();
let mut seen_cases = HashSet::new();
let mut current = cond;
loop {
let (case_discriminant, case_test) = extract_strict_case_test(¤t.test)?;
if let Some(existing) = &discriminant {
if !same_ident(existing, &case_discriminant) {
return None;
}
} else {
discriminant = Some(case_discriminant);
}
let key = literal_case_key(&case_test)?;
if !seen_cases.insert(key) {
return None;
}
cases.push((case_test, current.cons.clone()));
match current.alt.as_ref() {
Expr::Cond(next) => current = next,
_ => {
if cases.len() < 2 {
return None;
}
return Some(SwitchChain {
discriminant: discriminant.expect("set by first case"),
cases,
default: current.alt.clone(),
});
}
}
}
}
fn extract_strict_case_test(test: &Expr) -> Option<(Ident, Box<Expr>)> {
let Expr::Bin(BinExpr {
op: BinaryOp::EqEqEq,
left,
right,
..
}) = unparen_expr(test)
else {
return None;
};
match (unparen_expr(left), unparen_expr(right)) {
(Expr::Ident(discriminant), case) if literal_case_key(case).is_some() => {
Some((discriminant.clone(), Box::new(case.clone())))
}
(case, Expr::Ident(discriminant)) if literal_case_key(case).is_some() => {
Some((discriminant.clone(), Box::new(case.clone())))
}
_ => None,
}
}
fn switch_cases_from_expr_chain(chain: SwitchChain) -> Vec<SwitchCase> {
let mut cases = Vec::with_capacity(chain.cases.len() + 1);
for (test, body) in chain.cases {
cases.push(SwitchCase {
span: DUMMY_SP,
test: Some(test),
cons: expr_to_case_stmts(*body, true),
});
}
cases.push(SwitchCase {
span: DUMMY_SP,
test: None,
cons: expr_to_case_stmts(*chain.default, false),
});
cases
}
fn expr_to_case_stmts(expr: Expr, append_break: bool) -> Vec<Stmt> {
let inner = strip_parens_owned(expr);
let mut stmts = match inner {
Expr::Seq(seq) => seq
.exprs
.into_iter()
.flat_map(|expr| expr_to_case_stmts(*expr, false))
.collect(),
Expr::Cond(cond) => vec![convert_cond_to_if(
cond.span, *cond.test, cond.cons, cond.alt,
)],
other => convert_stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(other),
})),
};
if append_break {
stmts.push(Stmt::Break(BreakStmt {
span: DUMMY_SP,
label: None,
}));
}
stmts
}
fn chain_has_action(chain: &SwitchChain) -> bool {
chain.cases.iter().any(|(_, body)| is_action_expr(body)) || is_action_expr(&chain.default)
}
fn literal_case_key(expr: &Expr) -> Option<String> {
match unparen_expr(expr) {
Expr::Lit(Lit::Str(value)) => Some(format!("str:{}", value.value.to_string_lossy())),
Expr::Lit(Lit::Bool(value)) => Some(format!("bool:{}", value.value)),
Expr::Lit(Lit::Null(_)) => Some("null".to_string()),
Expr::Lit(Lit::Num(value)) => Some(numeric_case_key(value.value)),
Expr::Unary(UnaryExpr { op, arg, .. }) if matches!(op, UnaryOp::Plus | UnaryOp::Minus) => {
let Expr::Lit(Lit::Num(value)) = unparen_expr(arg) else {
return None;
};
let value = if *op == UnaryOp::Minus {
-value.value
} else {
value.value
};
Some(numeric_case_key(value))
}
Expr::Lit(Lit::BigInt(value)) => Some(format!("bigint:{}", value.value)),
_ => None,
}
}
fn numeric_case_key(value: f64) -> String {
format!("num:{}:{}", value, value.is_sign_positive())
}
fn unparen_expr(expr: &Expr) -> &Expr {
match expr {
Expr::Paren(paren) => unparen_expr(&paren.expr),
other => other,
}
}
/// Convert a ternary expression to an if statement.
fn convert_cond_to_if(span: Span, test: Expr, cons: Box<Expr>, alt: Box<Expr>) -> Stmt {
let cons_stmt = convert_cons_branch_to_stmt(*cons);
let alt_stmt = convert_alt_branch_to_stmt(*alt);
Stmt::If(IfStmt {
span,
test: Box::new(test),
cons: Box::new(cons_stmt),
alt: Some(Box::new(alt_stmt)),
})
}
/// Convert the consequent branch of a ternary to a statement.
/// If the cons is itself a ternary, wrap it in a block (not an else-if).
fn convert_cons_branch_to_stmt(expr: Expr) -> Stmt {
match expr {
Expr::Cond(inner) => {
// Nested ternary in cons position → convert to if, wrapped in a block
let inner_if = convert_cond_to_if(inner.span, *inner.test, inner.cons, inner.alt);
Stmt::Block(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts: vec![inner_if],
})
}
other => expr_to_block_stmt(other),
}
}
/// Convert the alternate branch of a ternary to a statement.
/// If the alt is another ternary/convertible-logical, make it an else-if (not wrapped in block).
fn convert_alt_branch_to_stmt(expr: Expr) -> Stmt {
match expr {
// Another ternary → becomes else-if chain
Expr::Cond(inner) => convert_cond_to_if(inner.span, *inner.test, inner.cons, inner.alt),
// Logical AND in alt → convert to if statement (not wrapped in block)
Expr::Bin(BinExpr {
op: BinaryOp::LogicalAnd,
left,
right,
..
}) if is_action_expr(&right) => Stmt::If(IfStmt {
span: DUMMY_SP,
test: left,
cons: Box::new(expr_to_block_stmt(*right)),
alt: None,
}),
// Logical OR in alt → convert to if statement
Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) if is_action_expr(&right) => Stmt::If(IfStmt {
span: DUMMY_SP,
test: negate_expr(*left),
cons: Box::new(expr_to_block_stmt(*right)),
alt: None,
}),
// Wrap in block
other => expr_to_block_stmt(other),
}
}
/// Wrap an expression in a block statement.
/// Sequence expressions (including paren-wrapped) are expanded into converted statements.
fn expr_to_block_stmt(expr: Expr) -> Stmt {
let inner = match expr {
Expr::Paren(paren) => *paren.expr,
other => other,
};
let stmts = match inner {
Expr::Seq(seq) => seq
.exprs
.into_iter()
.flat_map(|expr| {
convert_stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr,
}))
})
.collect(),
other => convert_stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(other),
})),
};
Stmt::Block(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts,
})
}
/// Negate an expression, removing double negation.
fn negate_expr(expr: Expr) -> Box<Expr> {
if let Expr::Unary(UnaryExpr {
op: UnaryOp::Bang,
arg,
..
}) = expr
{
return arg;
}
Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: UnaryOp::Bang,
arg: Box::new(expr),
}))
}
/// Try to split a `return cond ? a : b ? c : d` into
/// `if (cond) { return a; } if (b) { return c; } return d;`
/// Only converts if the top-level expression is a ternary.
fn try_split_return_ternary(expr: Expr, return_span: Span) -> Option<Vec<Stmt>> {
let Expr::Cond(cond) = expr else {
return None;
};
if let Some(switch_stmt) = try_cond_to_switch_return(&cond, return_span) {
return Some(vec![switch_stmt]);
}
let mut stmts = Vec::new();
build_return_chain(*cond.test, cond.cons, cond.alt, &mut stmts, return_span);
Some(stmts)
}
fn build_return_chain(
test: Expr,
cons: Box<Expr>,
alt: Box<Expr>,
stmts: &mut Vec<Stmt>,
span: Span,
) {
// if (test) { return cons; }
stmts.push(Stmt::If(IfStmt {
span: DUMMY_SP,
test: Box::new(test),
cons: Box::new(Stmt::Block(BlockStmt {
span: DUMMY_SP,
ctxt: Default::default(),
stmts: return_stmts_from_expr(*cons, span),
})),
alt: None,
}));
// Recurse or emit final return
match *alt {
Expr::Cond(next_cond) => {
build_return_chain(*next_cond.test, next_cond.cons, next_cond.alt, stmts, span);
}
other => {
stmts.push(Stmt::Return(ReturnStmt {
span,
arg: Some(Box::new(other)),
}));
}
}
}
fn return_stmts_from_expr(expr: Expr, span: Span) -> Vec<Stmt> {
match expr {
Expr::Cond(_) => try_split_return_ternary(expr, span).expect("checked it is Cond above"),
other => vec![Stmt::Return(ReturnStmt {
span,
arg: Some(Box::new(other)),
})],
}
}