crates/core/src/rules/un_optional_chaining.rs
GitHubuse std::collections::{HashMap, HashSet};
use swc_core::common::{Mark, Span, Spanned, DUMMY_SP};
use swc_core::ecma::ast::{
AssignOp, AssignTarget, BinExpr, BinaryOp, CallExpr, Callee, CondExpr, Expr, Ident, IfStmt,
Lit, MemberExpr, MemberProp, Module, OptCall, OptChainBase, OptChainExpr, SimpleAssignTarget,
Stmt, UnaryExpr, UnaryOp,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};
use super::binding_facts::collect_binding_facts;
use super::dead_decls::{
extend_consumed_uninitialized_expr, extend_consumed_uninitialized_stmt,
remove_consumed_uninitialized_decls,
};
use super::decl_utils::{binding_id, BindingId};
use super::expr_utils::{exprs_structurally_equal, is_unresolved_undefined};
use super::{RewriteLevel, RewritePolicy};
use crate::utils::paren::strip_parens;
pub struct UnOptionalChaining {
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: HashSet<BindingId>,
binding_references: HashMap<BindingId, usize>,
consumed_uninitialized_bindings: HashSet<BindingId>,
}
impl UnOptionalChaining {
pub fn new(unresolved_mark: Mark, level: RewriteLevel) -> Self {
Self {
unresolved_mark,
policy: RewritePolicy::from_level(level),
uninitialized_bindings: HashSet::new(),
binding_references: HashMap::new(),
consumed_uninitialized_bindings: HashSet::new(),
}
}
}
impl VisitMut for UnOptionalChaining {
fn visit_mut_module(&mut self, module: &mut Module) {
let facts = collect_binding_facts(module);
self.uninitialized_bindings = facts.uninitialized;
self.binding_references = facts.references;
self.consumed_uninitialized_bindings.clear();
module.visit_mut_children_with(self);
remove_consumed_uninitialized_decls(module, &self.consumed_uninitialized_bindings);
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if let Some(result) = try_boolean_context_logical_and_optional_chain(
expr,
self.unresolved_mark,
self.policy,
&self.uninitialized_bindings,
&self.binding_references,
) {
self.record_consumed_expr_bindings(expr, &result);
replace_expr_preserving_span(expr, result);
expr.visit_mut_children_with(self);
return;
}
if let Some(result) = try_optional_chaining(
expr,
self.unresolved_mark,
self.policy,
&self.uninitialized_bindings,
&self.binding_references,
) {
self.record_consumed_expr_bindings(expr, &result);
replace_expr_preserving_span(expr, result);
expr.visit_mut_children_with(self);
if let Some(result) = try_optional_call_cleanup(expr) {
self.record_consumed_expr_bindings(expr, &result);
replace_expr_preserving_span(expr, result);
}
return;
}
expr.visit_mut_children_with(self);
if let Some(result) = try_optional_call_cleanup(expr) {
self.record_consumed_expr_bindings(expr, &result);
replace_expr_preserving_span(expr, result);
return;
}
if let Some(result) = try_optional_chaining(
expr,
self.unresolved_mark,
self.policy,
&self.uninitialized_bindings,
&self.binding_references,
) {
self.record_consumed_expr_bindings(expr, &result);
replace_expr_preserving_span(expr, result);
}
}
fn visit_mut_stmt(&mut self, stmt: &mut Stmt) {
stmt.visit_mut_children_with(self);
if let Stmt::If(if_stmt) = stmt {
if let Some(result) = try_logical_and_optional_chain(
if_stmt.test.as_ref(),
self.unresolved_mark,
self.policy,
&self.uninitialized_bindings,
&self.binding_references,
) {
self.record_consumed_expr_bindings(if_stmt.test.as_ref(), &result);
*if_stmt.test = result;
}
}
if let Some(result) =
try_optional_call_short_circuit_stmt(stmt, self.unresolved_mark, self.policy)
{
self.record_consumed_stmt_bindings(stmt, &result);
*stmt = result;
return;
}
if let Some(result) = try_optional_call_if_stmt(stmt, self.unresolved_mark) {
self.record_consumed_stmt_bindings(stmt, &result);
*stmt = result;
}
}
}
/// Replace `*expr` with `result`, copying the original expression's span onto
/// the outermost node of the replacement for source map fidelity.
fn replace_expr_preserving_span(expr: &mut Expr, mut result: Expr) {
let original_span = expr.span();
if original_span.lo.0 != 0 {
propagate_span(&mut result, original_span);
}
*expr = result;
}
fn propagate_span(expr: &mut Expr, span: Span) {
match expr {
Expr::OptChain(e) => e.span = span,
Expr::Bin(e) => e.span = span,
Expr::Member(e) => e.span = span,
Expr::Call(e) => e.span = span,
_ => {}
}
}
impl UnOptionalChaining {
fn record_consumed_expr_bindings(&mut self, before: &Expr, after: &Expr) {
extend_consumed_uninitialized_expr(
&mut self.consumed_uninitialized_bindings,
before,
after,
&self.uninitialized_bindings,
&self.binding_references,
);
}
fn record_consumed_stmt_bindings(&mut self, before: &Stmt, after: &Stmt) {
extend_consumed_uninitialized_stmt(
&mut self.consumed_uninitialized_bindings,
before,
after,
&self.uninitialized_bindings,
&self.binding_references,
);
}
}
fn try_optional_call_cleanup(expr: &Expr) -> Option<Expr> {
let Expr::OptChain(OptChainExpr { base, .. }) = expr else {
return None;
};
let OptChainBase::Call(call) = base.as_ref() else {
return None;
};
let (context, call_args) = call.args.split_first()?;
let callee = extract_optional_call_target(call.callee.as_ref(), context.expr.as_ref())?;
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: call.span,
ctxt: call.ctxt,
callee: Box::new(callee),
args: call_args.to_vec(),
type_args: call.type_args.clone(),
})),
}))
}
fn try_optional_call_if_stmt(stmt: &Stmt, unresolved_mark: Mark) -> Option<Stmt> {
let Stmt::If(IfStmt {
test,
cons,
alt: None,
..
}) = stmt
else {
return None;
};
let Expr::Unary(UnaryExpr {
op: UnaryOp::Bang,
arg,
..
}) = test.as_ref()
else {
return None;
};
let NullCheckResult {
value: checked,
real_value,
} = extract_null_check(strip_parens(arg), unresolved_mark)?;
let real_rhs = real_value?;
let call_expr = extract_single_call_expr(cons)?;
build_optional_call_stmt(DUMMY_SP, &checked, &real_rhs, call_expr, unresolved_mark)
}
fn try_optional_call_short_circuit_stmt(
stmt: &Stmt,
unresolved_mark: Mark,
policy: RewritePolicy,
) -> Option<Stmt> {
let Stmt::Expr(expr_stmt) = stmt else {
return None;
};
let Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) = expr_stmt.expr.as_ref()
else {
return None;
};
if let Some(NullCheckResult {
value: checked,
real_value,
}) = extract_null_check(left, unresolved_mark)
{
return match real_value {
Some(real_rhs) => build_optional_call_stmt(
expr_stmt.span,
&checked,
&real_rhs,
right.as_ref(),
unresolved_mark,
),
None => build_direct_optional_call_stmt(expr_stmt.span, *checked, right),
};
}
try_loose_direct_optional_call_stmt(expr_stmt.span, left, right, unresolved_mark, policy)
}
/// Recover the statement-only form emitted by esbuild and Terser:
/// `handler == null || handler(value)` -> `handler?.(value)`.
///
/// The loose check relies on `no_document_all`. Keeping this statement-only is
/// also essential: the original expression yields `true` for a missing handler,
/// while the optional call yields `undefined`.
fn try_loose_direct_optional_call_stmt(
stmt_span: Span,
null_check: &Expr,
call_expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
) -> Option<Stmt> {
if !policy.assumptions.no_document_all {
return None;
}
let Expr::Bin(BinExpr {
op: BinaryOp::EqEq,
left,
right,
..
}) = strip_parens(null_check)
else {
return None;
};
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
build_direct_optional_call_stmt(stmt_span, checked, call_expr)
}
fn build_direct_optional_call_stmt(
stmt_span: Span,
checked: Expr,
call_expr: &Expr,
) -> Option<Stmt> {
let Expr::Ident(checked_ident) = strip_parens(&checked) else {
return None;
};
// Optional-call syntax makes eval indirect, unlike the guarded direct call.
if checked_ident.sym == "eval" {
return None;
}
let Expr::Call(CallExpr {
callee: Callee::Expr(callee),
args,
type_args,
span,
ctxt,
}) = strip_parens(call_expr)
else {
return None;
};
if !exprs_structurally_equal(&checked, callee) {
return None;
}
Some(Stmt::Expr(swc_core::ecma::ast::ExprStmt {
span: stmt_span,
expr: Box::new(Expr::OptChain(OptChainExpr {
span: *span,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(checked),
args: args.clone(),
type_args: type_args.clone(),
})),
})),
}))
}
fn extract_single_call_expr(stmt: &Stmt) -> Option<&Expr> {
match stmt {
Stmt::Block(block) if block.stmts.len() == 1 => extract_single_call_expr(&block.stmts[0]),
Stmt::Expr(expr_stmt) => Some(expr_stmt.expr.as_ref()),
_ => None,
}
}
fn build_optional_call_stmt(
stmt_span: swc_core::common::Span,
checked: &Expr,
real_rhs: &Expr,
call_expr: &Expr,
unresolved_mark: Mark,
) -> Option<Stmt> {
let Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
type_args,
span,
ctxt,
}) = call_expr
else {
return None;
};
let Expr::Member(MemberExpr { obj, prop, .. }) = callee_expr.as_ref() else {
return None;
};
if !prop.is_ident_with("call") || !exprs_structurally_equal(obj, checked) {
return None;
}
let (context, call_args) = args.split_first()?;
let callee = match strip_parens(real_rhs) {
Expr::OptChain(OptChainExpr { base, .. })
if matches!(base.as_ref(), OptChainBase::Member(_))
&& optional_call_context_matches_base(real_rhs, context.expr.as_ref()) =>
{
real_rhs.clone()
}
_ => recover_babel_optional_call_callee(real_rhs, context.expr.as_ref(), unresolved_mark)?,
};
Some(Stmt::Expr(swc_core::ecma::ast::ExprStmt {
span: stmt_span,
expr: Box::new(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(callee),
args: call_args.to_vec(),
type_args: type_args.clone(),
})),
})),
}))
}
fn try_optional_chaining(
expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
// Pattern: `(obj === null || obj === void 0) ? void 0 : obj.access`
if let Some(result) = try_ternary_optional_chain(
expr,
unresolved_mark,
policy,
uninitialized_bindings,
binding_references,
) {
return Some(result);
}
// Pattern: Babel-style flattened chains:
// `(_a = obj) === null || _a === void 0 || (_a = _a.prop) === null || ... ? void 0 : _a.leaf`
if let Some(result) = try_flattened_optional_chain(
expr,
unresolved_mark,
policy,
uninitialized_bindings,
binding_references,
) {
return Some(result);
}
// Pattern: `obj == null ? undefined : obj.access` (loose equality)
if let Some(result) = try_loose_eq_optional_chain(
expr,
unresolved_mark,
policy,
uninitialized_bindings,
binding_references,
) {
return Some(result);
}
None
}
fn try_boolean_context_logical_and_optional_chain(
expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
let Expr::Unary(UnaryExpr {
op: UnaryOp::Bang,
arg,
span,
}) = expr
else {
return None;
};
Some(Expr::Unary(UnaryExpr {
span: *span,
op: UnaryOp::Bang,
arg: Box::new(try_logical_and_optional_chain(
arg,
unresolved_mark,
policy,
uninitialized_bindings,
binding_references,
)?),
}))
}
fn try_logical_and_optional_chain(
expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
if policy.level < RewriteLevel::Standard {
return None;
}
let mut terms = Vec::new();
collect_logical_and_terms(expr, &mut terms);
if terms.len() < 3 {
return None;
}
rewrite_logical_and_optional_chain_terms(
&terms,
unresolved_mark,
policy,
uninitialized_bindings,
binding_references,
)
}
fn rewrite_logical_and_optional_chain_terms(
terms: &[&Expr],
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
let mut rewritten_terms = Vec::with_capacity(terms.len());
let mut changed = false;
let mut index = 0;
while index < terms.len() {
if let Some((chain, consumed)) = try_logical_and_optional_chain_prefix(
&terms[index..],
unresolved_mark,
policy,
uninitialized_bindings,
binding_references,
) {
rewritten_terms.push(chain);
index += consumed;
changed = true;
} else {
rewritten_terms.push(terms[index].clone());
index += 1;
}
}
changed.then(|| build_logical_and_expr(rewritten_terms))?
}
fn try_logical_and_optional_chain_prefix(
terms: &[&Expr],
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<(Expr, usize)> {
if terms.len() < 3 {
return None;
}
let first = extract_logical_and_non_null_segment(terms, 0, unresolved_mark, policy)?;
let mut temps = Vec::new();
let mut temp_values = HashMap::new();
let mut temp_call_contexts = HashMap::new();
let mut chain = if let Some(real_rhs) = first.real_rhs.as_ref() {
let Expr::Ident(tmp) = strip_parens(&first.checked) else {
return None;
};
temps.push(tmp.clone());
record_flattened_temp_value(
tmp,
real_rhs,
flattened_member_call_context(real_rhs, &temp_values),
&mut temp_values,
&mut temp_call_contexts,
);
real_rhs.clone()
} else {
if !matches!(strip_parens(&first.checked), Expr::Ident(_))
&& !policy.assumptions.pure_getters
{
return None;
}
first.checked.clone()
};
let mut current_tmp = first.checked;
let mut index = first.consumed;
while index < terms.len() {
let Some(segment) =
extract_logical_and_non_null_segment(terms, index, unresolved_mark, policy)
else {
break;
};
let real_rhs = segment.real_rhs.as_ref()?;
if index + segment.consumed >= terms.len() {
break;
}
let Expr::Ident(tmp) = strip_parens(&segment.checked) else {
return None;
};
let tmp = tmp.clone();
chain = make_optional_chain_replacing(¤t_tmp, &chain, real_rhs, unresolved_mark)?;
let call_context = flattened_member_call_context(real_rhs, &temp_values);
record_flattened_temp_value(
&tmp,
&chain,
call_context,
&mut temp_values,
&mut temp_call_contexts,
);
current_tmp = segment.checked;
temps.push(tmp);
index += segment.consumed;
}
if index >= terms.len() {
return None;
}
if !chain_temps_are_safe(
&temps,
&terms[..=index],
policy.level,
uninitialized_bindings,
binding_references,
) {
return None;
}
let chain = make_flattened_final_access(
¤t_tmp,
&chain,
terms[index],
&temp_values,
&temp_call_contexts,
unresolved_mark,
)?;
Some((chain, index + 1))
}
fn build_logical_and_expr(terms: Vec<Expr>) -> Option<Expr> {
let mut terms = terms.into_iter();
let first = terms.next()?;
Some(terms.fold(first, make_logical_and_expr))
}
fn make_logical_and_expr(left: Expr, right: Expr) -> Expr {
Expr::Bin(BinExpr {
span: DUMMY_SP,
op: BinaryOp::LogicalAnd,
left: Box::new(left),
right: Box::new(right),
})
}
struct LogicalAndSegment {
checked: Expr,
real_rhs: Option<Expr>,
consumed: usize,
}
fn extract_logical_and_non_null_segment(
terms: &[&Expr],
index: usize,
unresolved_mark: Mark,
policy: RewritePolicy,
) -> Option<LogicalAndSegment> {
if index + 1 < terms.len() {
if let Some(null_value) = extract_strict_not_null_single(terms[index]) {
if let Some(undefined_value) =
extract_strict_not_undefined_single(terms[index + 1], unresolved_mark)
{
if let Some((tmp, real_rhs)) = extract_assign_parts(&null_value) {
let checked = Expr::Ident(tmp);
if exprs_structurally_equal(&checked, &undefined_value) {
return Some(LogicalAndSegment {
checked,
real_rhs: Some((**real_rhs).clone()),
consumed: 2,
});
}
return None;
}
if exprs_structurally_equal(&null_value, &undefined_value) {
return Some(LogicalAndSegment {
checked: *undefined_value,
real_rhs: None,
consumed: 2,
});
}
}
}
}
if !policy.assumptions.no_document_all {
return None;
}
let checked = extract_loose_not_null_single(terms[index], unresolved_mark)?;
let (checked, real_rhs) = split_optional_assignment_checked_value(checked);
Some(LogicalAndSegment {
checked,
real_rhs,
consumed: 1,
})
}
fn split_optional_assignment_checked_value(checked: Expr) -> (Expr, Option<Expr>) {
if let Some((tmp, real_rhs)) = extract_assign_parts(&checked) {
(Expr::Ident(tmp), Some((**real_rhs).clone()))
} else {
(checked, None)
}
}
fn collect_logical_and_terms<'a>(expr: &'a Expr, terms: &mut Vec<&'a Expr>) {
match strip_parens(expr) {
Expr::Bin(BinExpr {
op: BinaryOp::LogicalAnd,
left,
right,
..
}) => {
collect_logical_and_terms(left, terms);
collect_logical_and_terms(right, terms);
}
expr => terms.push(expr),
}
}
fn extract_strict_not_null_single(expr: &Expr) -> Option<Box<Expr>> {
let Expr::Bin(BinExpr {
op: BinaryOp::NotEqEq,
left,
right,
..
}) = strip_parens(expr)
else {
return None;
};
if matches!(&**right, Expr::Lit(Lit::Null(_))) {
return Some(left.clone());
}
if matches!(&**left, Expr::Lit(Lit::Null(_))) {
return Some(right.clone());
}
None
}
fn extract_strict_not_undefined_single(expr: &Expr, unresolved_mark: Mark) -> Option<Box<Expr>> {
let Expr::Bin(BinExpr {
op: BinaryOp::NotEqEq,
left,
right,
..
}) = strip_parens(expr)
else {
return None;
};
if is_unresolved_undefined(right, unresolved_mark) {
return Some(left.clone());
}
if is_unresolved_undefined(left, unresolved_mark) {
return Some(right.clone());
}
None
}
fn extract_loose_not_null_single(expr: &Expr, unresolved_mark: Mark) -> Option<Expr> {
let Expr::Bin(BinExpr {
op: BinaryOp::NotEq,
left,
right,
..
}) = strip_parens(expr)
else {
return None;
};
extract_loose_null_operand(left, right, unresolved_mark)
}
fn try_flattened_optional_chain(
expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
if policy.level < RewriteLevel::Standard {
return None;
}
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = expr
else {
return None;
};
if !is_void_or_undefined(cons, unresolved_mark) {
return None;
}
try_flattened_strict_optional_chain(
test,
alt,
policy,
uninitialized_bindings,
binding_references,
unresolved_mark,
)
.or_else(|| {
try_flattened_mixed_loose_root_optional_chain(
test,
alt,
policy,
uninitialized_bindings,
binding_references,
unresolved_mark,
)
})
.or_else(|| {
try_flattened_loose_optional_chain(
test,
alt,
policy,
uninitialized_bindings,
binding_references,
unresolved_mark,
)
})
}
fn try_flattened_strict_optional_chain(
test: &Expr,
alt: &Expr,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
unresolved_mark: Mark,
) -> Option<Expr> {
let mut terms = Vec::new();
collect_logical_or_terms(test, &mut terms);
if terms.len() < 4 || terms.len() % 2 != 0 {
return None;
}
let first = extract_null_single(terms[0])?;
let (first_tmp, mut chain) =
extract_flattened_assignment_segment(&first, terms[1], unresolved_mark)?;
let mut temps = vec![first_tmp.clone()];
let mut temp_values = HashMap::new();
let mut temp_call_contexts = HashMap::new();
record_flattened_temp_value(
&first_tmp,
&chain,
None,
&mut temp_values,
&mut temp_call_contexts,
);
let mut current_tmp = Expr::Ident(first_tmp);
let mut index = 2;
while index < terms.len() {
let segment = extract_null_single(terms[index])?;
let (next_tmp, real_rhs) =
extract_flattened_assignment_segment(&segment, terms[index + 1], unresolved_mark)?;
chain = make_optional_chain_replacing(¤t_tmp, &chain, &real_rhs, unresolved_mark)?;
let call_context = flattened_member_call_context(&real_rhs, &temp_values);
record_flattened_temp_value(
&next_tmp,
&chain,
call_context,
&mut temp_values,
&mut temp_call_contexts,
);
current_tmp = Expr::Ident(next_tmp.clone());
temps.push(next_tmp);
index += 2;
}
if !flattened_chain_temps_are_safe(
&temps,
test,
alt,
policy.level,
uninitialized_bindings,
binding_references,
) {
return None;
}
make_flattened_final_access(
¤t_tmp,
&chain,
alt,
&temp_values,
&temp_call_contexts,
unresolved_mark,
)
}
fn try_flattened_mixed_loose_root_optional_chain(
test: &Expr,
alt: &Expr,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
unresolved_mark: Mark,
) -> Option<Expr> {
if !policy.assumptions.no_document_all {
return None;
}
let mut terms = Vec::new();
collect_logical_or_terms(test, &mut terms);
if terms.len() < 3 || terms.len() % 2 == 0 {
return None;
}
let base = extract_loose_null_single(terms[0], unresolved_mark)?;
if !matches!(strip_parens(&base), Expr::Ident(_)) && !policy.assumptions.pure_getters {
return None;
}
let mut chain = base.clone();
let mut current_tmp = base;
let mut temps = Vec::new();
let mut temp_values = HashMap::new();
let mut temp_call_contexts = HashMap::new();
let mut index = 1;
while index < terms.len() {
let segment = extract_null_single(terms[index])?;
let (next_tmp, real_rhs) =
extract_flattened_assignment_segment(&segment, terms[index + 1], unresolved_mark)?;
chain = make_optional_chain_replacing(¤t_tmp, &chain, &real_rhs, unresolved_mark)?;
let call_context = flattened_member_call_context(&real_rhs, &temp_values);
record_flattened_temp_value(
&next_tmp,
&chain,
call_context,
&mut temp_values,
&mut temp_call_contexts,
);
current_tmp = Expr::Ident(next_tmp.clone());
temps.push(next_tmp);
index += 2;
}
if !flattened_chain_temps_are_safe(
&temps,
test,
alt,
policy.level,
uninitialized_bindings,
binding_references,
) {
return None;
}
make_flattened_final_access(
¤t_tmp,
&chain,
alt,
&temp_values,
&temp_call_contexts,
unresolved_mark,
)
}
fn try_flattened_loose_optional_chain(
test: &Expr,
alt: &Expr,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
unresolved_mark: Mark,
) -> Option<Expr> {
if !policy.assumptions.no_document_all {
return None;
}
let mut terms = Vec::new();
collect_logical_or_terms(test, &mut terms);
if terms.len() < 2 {
return None;
}
let (first_tmp, mut chain) =
extract_flattened_loose_assignment_segment(terms[0], unresolved_mark)?;
let mut temps = vec![first_tmp.clone()];
let mut temp_values = HashMap::new();
let mut temp_call_contexts = HashMap::new();
record_flattened_temp_value(
&first_tmp,
&chain,
None,
&mut temp_values,
&mut temp_call_contexts,
);
let mut current_tmp = Expr::Ident(first_tmp);
for (index, term) in terms.iter().enumerate().skip(1) {
let Some((next_tmp, real_rhs)) =
extract_flattened_loose_assignment_segment(term, unresolved_mark)
else {
if index == terms.len() - 1 && policy.assumptions.pure_getters {
if !flattened_chain_temps_are_safe(
&temps,
test,
alt,
policy.level,
uninitialized_bindings,
binding_references,
) {
return None;
}
return make_flattened_loose_repeated_access(
¤t_tmp,
&chain,
term,
alt,
unresolved_mark,
);
}
return None;
};
chain = make_optional_chain_replacing(¤t_tmp, &chain, &real_rhs, unresolved_mark)?;
let call_context = flattened_member_call_context(&real_rhs, &temp_values);
record_flattened_temp_value(
&next_tmp,
&chain,
call_context,
&mut temp_values,
&mut temp_call_contexts,
);
current_tmp = Expr::Ident(next_tmp.clone());
temps.push(next_tmp);
}
if !flattened_chain_temps_are_safe(
&temps,
test,
alt,
policy.level,
uninitialized_bindings,
binding_references,
) {
return None;
}
make_flattened_final_access(
¤t_tmp,
&chain,
alt,
&temp_values,
&temp_call_contexts,
unresolved_mark,
)
}
fn make_flattened_loose_repeated_access(
current_tmp: &Expr,
chain: &Expr,
term: &Expr,
alt: &Expr,
unresolved_mark: Mark,
) -> Option<Expr> {
let Expr::Bin(BinExpr {
op: BinaryOp::EqEq,
left,
right,
..
}) = strip_parens(term)
else {
return None;
};
let checked_access = extract_loose_null_operand(left, right, unresolved_mark)?;
let optional_access =
make_optional_chain_replacing(current_tmp, chain, &checked_access, unresolved_mark)?;
if exprs_structurally_equal(alt, &checked_access) {
return Some(optional_access);
}
let Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
type_args,
span,
ctxt,
}) = strip_parens(alt)
else {
return None;
};
if !exprs_structurally_equal(callee_expr.as_ref(), &checked_access) {
return None;
}
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(optional_access),
args: args.clone(),
type_args: type_args.clone(),
})),
}))
}
fn collect_logical_or_terms<'a>(expr: &'a Expr, terms: &mut Vec<&'a Expr>) {
match strip_parens(expr) {
Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) => {
collect_logical_or_terms(left, terms);
collect_logical_or_terms(right, terms);
}
expr => terms.push(expr),
}
}
fn extract_flattened_assignment_segment(
null_value: &Expr,
undefined_check: &Expr,
unresolved_mark: Mark,
) -> Option<(Ident, Expr)> {
let (tmp, real_rhs) = extract_assign_ident_parts(null_value)?;
let undefined_value = extract_undefined_single(undefined_check, unresolved_mark)?;
if !exprs_structurally_equal(&Expr::Ident(tmp.clone()), &undefined_value) {
return None;
}
Some((tmp, *real_rhs.clone()))
}
fn extract_flattened_loose_assignment_segment(
term: &Expr,
unresolved_mark: Mark,
) -> Option<(Ident, Expr)> {
let Expr::Bin(BinExpr {
op: BinaryOp::EqEq,
left,
right,
..
}) = strip_parens(term)
else {
return None;
};
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
let (tmp, real_rhs) = extract_assign_ident_parts(&checked)?;
Some((tmp, *real_rhs.clone()))
}
fn extract_loose_null_single(expr: &Expr, unresolved_mark: Mark) -> Option<Expr> {
let Expr::Bin(BinExpr {
op: BinaryOp::EqEq,
left,
right,
..
}) = strip_parens(expr)
else {
return None;
};
extract_loose_null_operand(left, right, unresolved_mark)
}
fn record_flattened_temp_value(
tmp: &Ident,
value: &Expr,
call_context: Option<Expr>,
temp_values: &mut HashMap<BindingId, Expr>,
temp_call_contexts: &mut HashMap<BindingId, Expr>,
) {
let binding_id = binding_id(tmp);
temp_values.insert(binding_id.clone(), value.clone());
if let Some(call_context) = call_context {
temp_call_contexts.insert(binding_id, call_context);
}
}
fn flattened_member_call_context(
real_rhs: &Expr,
temp_values: &HashMap<BindingId, Expr>,
) -> Option<Expr> {
let Expr::Member(MemberExpr { obj, .. }) = strip_parens(real_rhs) else {
return None;
};
Some(resolve_flattened_temp_expr(obj, temp_values))
}
fn make_flattened_final_access(
current_tmp: &Expr,
chain: &Expr,
access: &Expr,
temp_values: &HashMap<BindingId, Expr>,
temp_call_contexts: &HashMap<BindingId, Expr>,
unresolved_mark: Mark,
) -> Option<Expr> {
if let Some(chain) = make_optional_chain_replacing(current_tmp, chain, access, unresolved_mark)
{
return Some(chain);
}
make_flattened_optional_call(current_tmp, chain, access, temp_values, temp_call_contexts)
}
fn make_flattened_optional_call(
current_tmp: &Expr,
chain: &Expr,
access: &Expr,
temp_values: &HashMap<BindingId, Expr>,
temp_call_contexts: &HashMap<BindingId, Expr>,
) -> Option<Expr> {
let Expr::Ident(current_ident) = strip_parens(current_tmp) else {
return None;
};
let Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
type_args,
span,
ctxt,
}) = access
else {
return None;
};
let Expr::Member(MemberExpr { obj, prop, .. }) = callee_expr.as_ref() else {
return None;
};
if !prop.is_ident_with("call") || !exprs_structurally_equal(obj, current_tmp) {
return None;
}
let (context, call_args) = args.split_first()?;
let binding_id = binding_id(current_ident);
let expected_context = temp_call_contexts.get(&binding_id)?;
let actual_context = resolve_flattened_temp_expr(context.expr.as_ref(), temp_values);
if !flattened_call_contexts_equal(expected_context, &actual_context) {
return None;
}
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(chain.clone()),
args: call_args.to_vec(),
type_args: type_args.clone(),
})),
}))
}
fn resolve_flattened_temp_expr(expr: &Expr, temp_values: &HashMap<BindingId, Expr>) -> Expr {
let Expr::Ident(ident) = strip_parens(expr) else {
return expr.clone();
};
temp_values
.get(&binding_id(ident))
.cloned()
.unwrap_or_else(|| expr.clone())
}
fn flattened_call_contexts_equal(a: &Expr, b: &Expr) -> bool {
if exprs_structurally_equal(a, b) {
return true;
}
match (strip_parens(a), strip_parens(b)) {
(
Expr::OptChain(OptChainExpr {
base: a_base,
optional: a_optional,
..
}),
Expr::OptChain(OptChainExpr {
base: b_base,
optional: b_optional,
..
}),
) if a_optional == b_optional => match (a_base.as_ref(), b_base.as_ref()) {
(
OptChainBase::Member(MemberExpr {
obj: a_obj,
prop: a_prop,
..
}),
OptChainBase::Member(MemberExpr {
obj: b_obj,
prop: b_prop,
..
}),
) => {
member_props_equal(a_prop, b_prop)
&& flattened_call_contexts_equal(a_obj.as_ref(), b_obj.as_ref())
}
_ => false,
},
_ => false,
}
}
fn member_props_equal(a: &MemberProp, b: &MemberProp) -> bool {
match (a, b) {
(MemberProp::Ident(ai), MemberProp::Ident(bi)) => ai.sym == bi.sym,
(MemberProp::Computed(ac), MemberProp::Computed(bc)) => {
flattened_call_contexts_equal(ac.expr.as_ref(), bc.expr.as_ref())
}
_ => false,
}
}
fn flattened_chain_temps_are_safe(
temps: &[Ident],
test: &Expr,
alt: &Expr,
level: RewriteLevel,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> bool {
chain_temps_are_safe(
temps,
&[test, alt],
level,
uninitialized_bindings,
binding_references,
)
}
fn chain_temps_are_safe(
temps: &[Ident],
pattern_exprs: &[&Expr],
level: RewriteLevel,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> bool {
let pattern_references = count_binding_references_in_exprs(pattern_exprs);
let unique_temps: HashSet<BindingId> = temps.iter().map(binding_id).collect();
unique_temps.iter().all(|binding_id| {
let pattern_count = pattern_references.get(binding_id).copied().unwrap_or(0);
let total_count = binding_references.get(binding_id).copied().unwrap_or(0);
if uninitialized_bindings.contains(binding_id) && total_count == pattern_count + 1 {
return true;
}
if level >= RewriteLevel::Aggressive
&& looks_generated_temp_sym(&binding_id.0)
&& total_count == pattern_count
{
return true;
}
false
})
}
fn temp_expr_is_safe_for_pattern(
temp: &Expr,
exprs: &[&Expr],
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> bool {
let Expr::Ident(Ident { sym, ctxt, .. }) = strip_parens(temp) else {
return false;
};
let binding_id = (sym.clone(), *ctxt);
let pattern_references = count_binding_references_in_exprs(exprs)
.get(&binding_id)
.copied()
.unwrap_or(0);
let total_references = binding_references.get(&binding_id).copied().unwrap_or(0);
if uninitialized_bindings.contains(&binding_id) && total_references == pattern_references + 1 {
return true;
}
looks_generated_temp_sym(sym) && total_references == pattern_references
}
fn count_binding_references_in_exprs(exprs: &[&Expr]) -> HashMap<BindingId, usize> {
let mut counter = BindingReferenceCounter::default();
for expr in exprs {
expr.visit_with(&mut counter);
}
counter.references
}
/// Handle: `(obj === null || obj === void 0) ? void 0 : obj.access` → `obj?.access`
/// Also handles assignment form: `(tmp = expr) === null || tmp === void 0 ? void 0 : tmp.access`
fn try_ternary_optional_chain(
expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = expr
else {
return None;
};
// consequent must be `void 0` or `undefined`
if !is_void_or_undefined(cons, unresolved_mark) {
return None;
}
// test must be `x === null || x === void 0`
let NullCheckResult {
value: checked,
real_value,
} = extract_null_check(test, unresolved_mark)?;
if let Some(real_rhs) = real_value {
// Strict Babel lowering references the temp four times:
// assignment target, null check left/right, and the final access/call.
if is_standard_temp_expr(&checked, uninitialized_bindings, binding_references, 4)
|| is_generated_temp_expr(&checked, binding_references, 3)
// Generated member/nested-chain temps skip the declaration-site proof, so we only
// require the three references inside the lowered chain itself.
|| is_generated_member_temp_expr(&checked, &real_rhs, binding_references, 3)
|| is_nested_optional_chain_temp_expr(&checked, &real_rhs, binding_references, 3)
|| (is_optional_call_on_checked(alt, &checked)
&& (is_standard_temp_expr(
&checked,
uninitialized_bindings,
binding_references,
5,
) || is_generated_member_temp_expr(&checked, &real_rhs, binding_references, 5)))
{
if let Some(chain) =
make_optional_chain_replacing(&checked, &real_rhs, alt, unresolved_mark)
{
return (policy.level >= RewriteLevel::Standard).then_some(chain);
}
}
if policy.level < RewriteLevel::Aggressive {
return None;
}
// Assignment form: `checked` is `tmp`, `real_rhs` is the original expr
// alt must use `tmp` as the object
return make_optional_chain_replacing(&checked, &real_rhs, alt, unresolved_mark);
}
// Plain form
make_optional_chain(*checked, alt)
}
/// Build `base?.prop` or `base?.method(...)` where `access` uses `base` as its object.
fn make_optional_chain(base: Expr, access: &Expr) -> Option<Expr> {
match access {
// x.prop → x?.prop
Expr::Member(MemberExpr { obj, prop, .. }) if exprs_structurally_equal(obj, &base) => {
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(base),
prop: prop.clone(),
})),
}))
}
// x.prop.deep → x?.prop.deep
Expr::Member(MemberExpr { obj, prop, .. }) => {
let replaced_obj = make_optional_chain(base, obj)?;
Some(make_required_member_tail(replaced_obj, prop.clone()))
}
// x(...) → x?.(...)
Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
type_args,
span,
ctxt,
}) => {
if matches!(&base, Expr::Ident(ident) if ident.sym != "eval")
&& exprs_structurally_equal(callee_expr, &base)
{
return Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(base),
args: args.clone(),
type_args: type_args.clone(),
})),
}));
}
// x.method(...) → x?.method(...)
if let Expr::Member(MemberExpr { obj, prop, .. }) = &**callee_expr {
if exprs_structurally_equal(obj, &base) {
if prop.is_ident_with("call")
&& optional_call_context_matches_base(&base, args.first()?.expr.as_ref())
{
return Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(base),
args: args[1..].to_vec(),
type_args: type_args.clone(),
})),
}));
}
let opt_member = Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(base),
prop: prop.clone(),
})),
});
return Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: false,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(opt_member),
args: args.clone(),
type_args: type_args.clone(),
})),
}));
}
}
None
}
_ => None,
}
}
fn is_optional_call_on_checked(access: &Expr, checked: &Expr) -> bool {
let Expr::OptChain(OptChainExpr { base, .. }) = strip_parens(access) else {
return false;
};
let OptChainBase::Call(OptCall { callee, .. }) = base.as_ref() else {
return false;
};
match strip_parens(callee.as_ref()) {
Expr::Member(MemberExpr { obj, .. }) => exprs_structurally_equal(obj, checked),
Expr::OptChain(OptChainExpr { base, .. }) => match base.as_ref() {
OptChainBase::Member(MemberExpr { obj, .. }) => exprs_structurally_equal(obj, checked),
OptChainBase::Call(_) => false,
},
_ => false,
}
}
fn make_required_member_tail(obj: Expr, prop: MemberProp) -> Expr {
if matches!(strip_parens(&obj), Expr::OptChain(_)) {
return Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: false,
base: Box::new(OptChainBase::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(obj),
prop,
})),
});
}
Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(obj),
prop,
})
}
/// Build an optional chain for the assignment temp-var case.
/// `tmp` is the temp variable expr, `real_rhs` is what it was assigned from.
/// `access` should use `tmp` as its object; we replace `tmp` with `real_rhs` in the output.
fn make_optional_chain_replacing(
tmp: &Expr,
real_rhs: &Expr,
access: &Expr,
unresolved_mark: Mark,
) -> Option<Expr> {
match access {
Expr::Member(MemberExpr { obj, prop, .. }) if exprs_structurally_equal(obj, tmp) => {
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(real_rhs.clone()),
prop: prop.clone(),
})),
}))
}
Expr::Member(MemberExpr { obj, prop, .. }) => {
let replaced_obj = make_optional_chain_replacing(tmp, real_rhs, obj, unresolved_mark)?;
Some(make_required_member_tail(replaced_obj, prop.clone()))
}
Expr::OptChain(OptChainExpr {
base: opt_base,
optional,
..
}) => match opt_base.as_ref() {
OptChainBase::Member(MemberExpr { obj, prop, .. }) => {
let replaced_obj = if exprs_structurally_equal(obj, tmp) {
real_rhs.clone()
} else {
make_optional_chain_replacing(tmp, real_rhs, obj, unresolved_mark)?
};
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: *optional,
base: Box::new(OptChainBase::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(replaced_obj),
prop: prop.clone(),
})),
}))
}
OptChainBase::Call(OptCall {
callee,
args,
type_args,
span,
ctxt,
}) => {
let replaced_callee =
make_optional_chain_replacing(tmp, real_rhs, callee, unresolved_mark)?;
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: *optional,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(replaced_callee),
args: args.clone(),
type_args: type_args.clone(),
})),
}))
}
},
Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
type_args,
span,
ctxt,
}) => {
if let Expr::Member(MemberExpr { obj, prop, .. }) = &**callee_expr {
if exprs_structurally_equal(obj, tmp) {
if prop.is_ident_with("call") {
return make_optional_call_replacing(
real_rhs,
args,
type_args,
*span,
*ctxt,
unresolved_mark,
);
}
let opt_member = Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(real_rhs.clone()),
prop: prop.clone(),
})),
});
return Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: false,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(opt_member),
args: args.clone(),
type_args: type_args.clone(),
})),
}));
}
}
if let Some(replaced_callee) =
make_optional_chain_replacing(tmp, real_rhs, callee_expr, unresolved_mark)
{
return Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: false,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(replaced_callee),
args: args.clone(),
type_args: type_args.clone(),
})),
}));
}
None
}
_ => None,
}
}
/// Handle loose equality forms:
/// - `obj == null ? undefined : obj.prop` → `obj?.prop`
/// - `obj != null ? obj.prop : undefined` → `obj?.prop`
/// - `(tmp = expr) == null ? undefined : tmp.prop` → `expr?.prop` (aggressive)
/// - `(tmp = expr) != null ? tmp.prop : undefined` → `expr?.prop` (aggressive)
///
/// `x == null` matches both `null` and `undefined`, which is exactly what `?.` does.
fn try_loose_eq_optional_chain(
expr: &Expr,
unresolved_mark: Mark,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
if !policy.assumptions.no_document_all {
return None;
}
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = expr
else {
return None;
};
let Expr::Bin(BinExpr {
op, left, right, ..
}) = &**test
else {
return None;
};
match op {
// `x == null ? undefined : x.prop`
// `(tmp = expr) == null ? undefined : tmp.prop`
BinaryOp::EqEq => {
if !is_void_or_undefined(cons, unresolved_mark) {
return None;
}
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
try_loose_chain_with_assign(
checked,
alt,
policy,
uninitialized_bindings,
binding_references,
unresolved_mark,
)
}
// `x != null ? x.prop : undefined`
// `(tmp = expr) != null ? tmp.prop : undefined`
BinaryOp::NotEq => {
if !is_void_or_undefined(alt, unresolved_mark) {
return None;
}
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
try_loose_chain_with_assign(
checked,
cons,
policy,
uninitialized_bindings,
binding_references,
unresolved_mark,
)
}
_ => None,
}
}
fn try_loose_chain_with_assign(
checked: Expr,
access: &Expr,
policy: RewritePolicy,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
unresolved_mark: Mark,
) -> Option<Expr> {
if let Some((tmp, real_rhs)) = extract_assign_parts(&checked) {
let tmp_ident_expr = find_ident_by_binding(access, &tmp)?;
let recovered_real_rhs = recover_lowered_optional_chain_expr(real_rhs, unresolved_mark)
.map(|recovered| recovered.chain);
// Loose Babel lowering references the temp twice inside the chain:
// once in the null check and once in the final access/call.
if is_standard_temp_expr(
&tmp_ident_expr,
uninitialized_bindings,
binding_references,
3,
) || is_generated_temp_expr(&tmp_ident_expr, binding_references, 2)
|| is_generated_member_temp_expr(&tmp_ident_expr, real_rhs, binding_references, 2)
|| is_nested_optional_chain_temp_expr(&tmp_ident_expr, real_rhs, binding_references, 2)
|| temp_expr_is_safe_for_pattern(
&tmp_ident_expr,
&[&checked, access],
uninitialized_bindings,
binding_references,
)
{
if let Some(chain) = make_optional_chain_replacing_preferred(
&tmp_ident_expr,
real_rhs,
recovered_real_rhs.as_ref(),
access,
unresolved_mark,
) {
return Some(chain);
}
}
if policy.assumptions.pure_getters {
if let Some(recovered_access) =
recover_loose_repeated_optional_call_chain(access, unresolved_mark)
{
if let Some(chain) = make_optional_chain_replacing(
&tmp_ident_expr,
real_rhs,
&recovered_access,
unresolved_mark,
) {
return Some(chain);
}
}
}
if policy.level < RewriteLevel::Aggressive {
return None;
}
make_optional_chain_replacing_preferred(
&tmp_ident_expr,
real_rhs,
recovered_real_rhs.as_ref(),
access,
unresolved_mark,
)
} else {
make_optional_chain(checked, access)
}
}
fn recover_loose_repeated_optional_call_chain(expr: &Expr, unresolved_mark: Mark) -> Option<Expr> {
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = strip_parens(expr)
else {
return None;
};
if !is_void_or_undefined(cons, unresolved_mark) {
return None;
}
let Expr::Bin(BinExpr {
op: BinaryOp::EqEq,
left,
right,
..
}) = test.as_ref()
else {
return None;
};
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
if let Some((tmp, real_rhs)) = extract_assign_parts(&checked) {
let tmp_ident_expr = find_ident_by_binding(alt, &tmp)?;
let recovered_alt = recover_loose_repeated_optional_call_chain(alt, unresolved_mark)?;
return make_optional_chain_replacing(
&tmp_ident_expr,
real_rhs,
&recovered_alt,
unresolved_mark,
);
}
let Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
type_args,
span,
ctxt,
}) = strip_parens(alt)
else {
return None;
};
if !exprs_structurally_equal(callee_expr.as_ref(), &checked) {
return None;
}
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span: *span,
ctxt: *ctxt,
callee: Box::new(checked),
args: args.clone(),
type_args: type_args.clone(),
})),
}))
}
fn make_optional_chain_replacing_preferred(
tmp: &Expr,
original_rhs: &Expr,
recovered_rhs: Option<&Expr>,
access: &Expr,
unresolved_mark: Mark,
) -> Option<Expr> {
if is_call_expr(access) {
return make_optional_chain_replacing(tmp, original_rhs, access, unresolved_mark).or_else(
|| make_optional_chain_replacing(tmp, recovered_rhs?, access, unresolved_mark),
);
}
if let Some(recovered_access) = recover_lowered_optional_chain_expr(access, unresolved_mark)
.map(|recovered| recovered.chain)
{
if let Some(chain) = recovered_rhs
.and_then(|real_rhs| {
make_optional_chain_replacing(tmp, real_rhs, &recovered_access, unresolved_mark)
})
.or_else(|| {
make_optional_chain_replacing(tmp, original_rhs, &recovered_access, unresolved_mark)
})
{
return Some(chain);
}
}
recovered_rhs
.and_then(|real_rhs| make_optional_chain_replacing(tmp, real_rhs, access, unresolved_mark))
.or_else(|| make_optional_chain_replacing(tmp, original_rhs, access, unresolved_mark))
}
fn is_call_expr(expr: &Expr) -> bool {
matches!(strip_parens(expr), Expr::Call(_))
}
fn find_ident_by_binding(access: &Expr, binding: &Ident) -> Option<Expr> {
match access {
Expr::Paren(paren) => find_ident_by_binding(&paren.expr, binding),
Expr::Ident(id) if same_binding(id, binding) => Some(Expr::Ident(id.clone())),
Expr::Cond(CondExpr {
test, cons, alt, ..
}) => find_ident_by_binding(test, binding)
.or_else(|| find_ident_by_binding(cons, binding))
.or_else(|| find_ident_by_binding(alt, binding)),
Expr::Bin(BinExpr { left, right, .. }) => {
find_ident_by_binding(left, binding).or_else(|| find_ident_by_binding(right, binding))
}
Expr::Assign(assign) => find_ident_by_binding(&assign.right, binding),
Expr::Member(MemberExpr { obj, .. }) => {
if let Expr::Ident(id) = &**obj {
if same_binding(id, binding) {
return Some(Expr::Ident(id.clone()));
}
}
find_ident_by_binding(obj, binding)
}
Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
..
}) => find_ident_by_binding(callee_expr, binding),
Expr::OptChain(OptChainExpr { base, .. }) => match base.as_ref() {
OptChainBase::Member(MemberExpr { obj, .. }) => find_ident_by_binding(obj, binding),
OptChainBase::Call(OptCall { callee, .. }) => find_ident_by_binding(callee, binding),
},
_ => None,
}
}
fn same_binding(a: &Ident, b: &Ident) -> bool {
a.sym == b.sym && a.ctxt == b.ctxt
}
/// From a binary `x == null` or `null == x`, extract the non-null operand.
fn extract_loose_null_operand(
left: &Box<Expr>,
right: &Box<Expr>,
unresolved_mark: Mark,
) -> Option<Expr> {
if matches!(&**right, Expr::Lit(Lit::Null(_)))
|| is_unresolved_undefined(right, unresolved_mark)
{
return Some((**left).clone());
}
if matches!(&**left, Expr::Lit(Lit::Null(_))) || is_unresolved_undefined(left, unresolved_mark)
{
return Some((**right).clone());
}
None
}
// ---------------------------------------------------------------------------
// Null-check extraction helpers
// ---------------------------------------------------------------------------
struct NullCheckResult {
value: Box<Expr>,
real_value: Option<Box<Expr>>,
}
/// Extract from `x === null || x === void 0`.
/// Handles assignment form `(tmp = expr) === null || tmp === void 0`.
fn extract_null_check(expr: &Expr, unresolved_mark: Mark) -> Option<NullCheckResult> {
let Expr::Bin(BinExpr {
op: BinaryOp::LogicalOr,
left,
right,
..
}) = expr
else {
return None;
};
let left_val = extract_null_single(left)?;
let right_val = extract_undefined_single(right, unresolved_mark)?;
if let Some((tmp, real_rhs)) = extract_assign_parts(&left_val) {
if let Expr::Ident(ri) = &*right_val {
if same_binding(ri, &tmp) {
return Some(NullCheckResult {
value: Box::new(Expr::Ident(ri.clone())),
real_value: Some(real_rhs.clone()),
});
}
}
return None;
}
if !exprs_structurally_equal(&left_val, &right_val) {
return None;
}
Some(NullCheckResult {
value: left_val,
real_value: None,
})
}
/// Extract from `x !== null && x !== void 0`.
fn extract_null_single(expr: &Expr) -> Option<Box<Expr>> {
let Expr::Bin(BinExpr {
op, left, right, ..
}) = expr
else {
return None;
};
if !matches!(op, BinaryOp::EqEqEq | BinaryOp::EqEq) {
return None;
}
if matches!(&**right, Expr::Lit(Lit::Null(_))) {
return Some(left.clone());
}
if matches!(&**left, Expr::Lit(Lit::Null(_))) {
return Some(right.clone());
}
None
}
fn extract_undefined_single(expr: &Expr, unresolved_mark: Mark) -> Option<Box<Expr>> {
let Expr::Bin(BinExpr {
op, left, right, ..
}) = expr
else {
return None;
};
if !matches!(op, BinaryOp::EqEqEq | BinaryOp::EqEq) {
return None;
}
if is_unresolved_undefined(right, unresolved_mark) {
return Some(left.clone());
}
if is_unresolved_undefined(left, unresolved_mark) {
return Some(right.clone());
}
None
}
fn is_void_or_undefined(expr: &Expr, unresolved_mark: Mark) -> bool {
is_unresolved_undefined(expr, unresolved_mark)
}
fn make_optional_call_replacing(
real_rhs: &Expr,
args: &[swc_core::ecma::ast::ExprOrSpread],
type_args: &Option<Box<swc_core::ecma::ast::TsTypeParamInstantiation>>,
span: swc_core::common::Span,
ctxt: swc_core::common::SyntaxContext,
unresolved_mark: Mark,
) -> Option<Expr> {
let (context, call_args) = args.split_first()?;
let recovered_callee =
recover_babel_optional_call_callee(real_rhs, context.expr.as_ref(), unresolved_mark)?;
Some(Expr::OptChain(OptChainExpr {
span: DUMMY_SP,
optional: true,
base: Box::new(OptChainBase::Call(OptCall {
span,
ctxt,
callee: Box::new(recovered_callee),
args: call_args.to_vec(),
type_args: type_args.clone(),
})),
}))
}
fn extract_optional_call_target(callee: &Expr, context: &Expr) -> Option<Expr> {
match strip_parens(callee) {
Expr::Member(MemberExpr { obj, prop, .. }) if prop.is_ident_with("call") => {
optional_call_context_matches_base(obj, context).then(|| (**obj).clone())
}
Expr::OptChain(OptChainExpr { base, .. }) => match base.as_ref() {
OptChainBase::Member(MemberExpr { obj, prop, .. }) if prop.is_ident_with("call") => {
optional_call_context_matches_base(obj, context).then(|| (**obj).clone())
}
_ => None,
},
_ => None,
}
}
fn optional_call_context_matches_base(base: &Expr, context: &Expr) -> bool {
match strip_parens(base) {
Expr::Member(MemberExpr { obj, .. }) => recover_babel_call_context(obj, context).is_some(),
Expr::OptChain(OptChainExpr { base: opt_base, .. }) => match opt_base.as_ref() {
OptChainBase::Member(MemberExpr { obj, .. }) => {
recover_babel_call_context(obj, context).is_some()
}
_ => false,
},
_ => false,
}
}
fn recover_babel_optional_call_callee(
real_rhs: &Expr,
context: &Expr,
unresolved_mark: Mark,
) -> Option<Expr> {
match strip_parens(real_rhs) {
Expr::Member(MemberExpr { obj, prop, .. }) => {
let recovered_obj = recover_babel_call_context(obj, context)?;
Some(Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(recovered_obj),
prop: prop.clone(),
}))
}
Expr::OptChain(OptChainExpr { base, .. }) => match base.as_ref() {
OptChainBase::Member(MemberExpr { obj, .. })
if recover_babel_call_context(obj, context).is_some() =>
{
Some(real_rhs.clone())
}
_ => None,
},
_ => {
let recovered = recover_lowered_optional_chain_expr(real_rhs, unresolved_mark)?;
if let Some(expected_context) = recovered.expected_context.as_ref() {
if !exprs_structurally_equal(context, expected_context) {
return None;
}
}
Some(recovered.chain)
}
}
}
struct RecoveredLoweredOptionalChain {
chain: Expr,
expected_context: Option<Expr>,
}
fn recover_lowered_optional_chain_expr(
expr: &Expr,
unresolved_mark: Mark,
) -> Option<RecoveredLoweredOptionalChain> {
if let Some(recovered) = recover_strict_lowered_optional_chain_expr(expr, unresolved_mark) {
return Some(recovered);
}
recover_loose_lowered_optional_chain_expr(expr, unresolved_mark)
}
fn recover_strict_lowered_optional_chain_expr(
expr: &Expr,
unresolved_mark: Mark,
) -> Option<RecoveredLoweredOptionalChain> {
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = strip_parens(expr)
else {
return None;
};
if !is_void_or_undefined(cons, unresolved_mark) {
return None;
}
let NullCheckResult {
value: checked,
real_value,
} = extract_null_check(test, unresolved_mark)?;
let expected_context = Some((*checked).clone());
let chain = if let Some(real_rhs) = real_value {
make_optional_chain_replacing(&checked, &real_rhs, alt, unresolved_mark)?
} else {
make_optional_chain(*checked, alt)?
};
Some(RecoveredLoweredOptionalChain {
chain,
expected_context,
})
}
fn recover_loose_lowered_optional_chain_expr(
expr: &Expr,
unresolved_mark: Mark,
) -> Option<RecoveredLoweredOptionalChain> {
let Expr::Cond(CondExpr {
test, cons, alt, ..
}) = strip_parens(expr)
else {
return None;
};
let Expr::Bin(BinExpr {
op, left, right, ..
}) = &**test
else {
return None;
};
match op {
BinaryOp::EqEq => {
if !is_void_or_undefined(cons, unresolved_mark) {
return None;
}
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
recover_loose_lowered_optional_chain_parts(checked, alt, unresolved_mark)
}
BinaryOp::NotEq => {
if !is_void_or_undefined(alt, unresolved_mark) {
return None;
}
let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
recover_loose_lowered_optional_chain_parts(checked, cons, unresolved_mark)
}
_ => None,
}
}
fn recover_loose_lowered_optional_chain_parts(
checked: Expr,
access: &Expr,
unresolved_mark: Mark,
) -> Option<RecoveredLoweredOptionalChain> {
if let Some((tmp, real_rhs)) = extract_assign_parts(&checked) {
let tmp_ident_expr = find_ident_by_binding(access, &tmp)?;
Some(RecoveredLoweredOptionalChain {
chain: make_optional_chain_replacing(
&tmp_ident_expr,
real_rhs,
access,
unresolved_mark,
)?,
expected_context: Some(tmp_ident_expr),
})
} else {
Some(RecoveredLoweredOptionalChain {
chain: make_optional_chain(checked, access)?,
expected_context: None,
})
}
}
fn recover_babel_call_context(member_obj: &Expr, context: &Expr) -> Option<Expr> {
if exprs_structurally_equal(member_obj, context) {
return Some(member_obj.clone());
}
let Expr::Ident(context_ident) = strip_parens(context) else {
return None;
};
let (assigned, assigned_rhs) = extract_assign_parts(member_obj)?;
if same_binding(&assigned, context_ident) {
return Some((**assigned_rhs).clone());
}
None
}
fn extract_assign_parts(expr: &Expr) -> Option<(Ident, &Box<Expr>)> {
let Expr::Assign(assign) = strip_parens(expr) else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(id)) = &assign.left else {
return None;
};
Some((id.id.clone(), &assign.right))
}
fn extract_assign_ident_parts(expr: &Expr) -> Option<(Ident, &Box<Expr>)> {
let Expr::Assign(assign) = strip_parens(expr) else {
return None;
};
if assign.op != AssignOp::Assign {
return None;
}
let AssignTarget::Simple(SimpleAssignTarget::Ident(id)) = &assign.left else {
return None;
};
Some((id.id.clone(), &assign.right))
}
fn is_standard_temp_expr(
expr: &Expr,
uninitialized_bindings: &HashSet<BindingId>,
binding_references: &HashMap<BindingId, usize>,
expected_references: usize,
) -> bool {
let Expr::Ident(Ident { sym, ctxt, .. }) = strip_parens(expr) else {
return false;
};
let binding_id = (sym.clone(), *ctxt);
uninitialized_bindings.contains(&binding_id)
&& binding_references.get(&binding_id).copied() == Some(expected_references)
}
fn is_generated_temp_expr(
checked: &Expr,
binding_references: &HashMap<BindingId, usize>,
expected_references: usize,
) -> bool {
let Expr::Ident(Ident { sym, ctxt, .. }) = strip_parens(checked) else {
return false;
};
let binding_id = (sym.clone(), *ctxt);
looks_generated_temp_sym(sym)
&& binding_references.get(&binding_id).copied() == Some(expected_references)
}
fn is_nested_optional_chain_temp_expr(
checked: &Expr,
real_rhs: &Expr,
binding_references: &HashMap<BindingId, usize>,
expected_references: usize,
) -> bool {
if !matches!(strip_parens(real_rhs), Expr::OptChain(_)) {
return false;
}
let Expr::Ident(Ident { sym, ctxt, .. }) = strip_parens(checked) else {
return false;
};
let binding_id = (sym.clone(), *ctxt);
looks_generated_temp_sym(sym)
&& binding_references.get(&binding_id).copied() == Some(expected_references)
}
fn is_generated_member_temp_expr(
checked: &Expr,
real_rhs: &Expr,
binding_references: &HashMap<BindingId, usize>,
expected_references: usize,
) -> bool {
if !matches!(strip_parens(real_rhs), Expr::Member(_)) {
return false;
}
let Expr::Ident(Ident { sym, ctxt, .. }) = strip_parens(checked) else {
return false;
};
let binding_id = (sym.clone(), *ctxt);
looks_generated_temp_sym(sym)
&& binding_references.get(&binding_id).copied() == Some(expected_references)
}
fn is_babel_temp_sym(sym: &swc_core::atoms::Atom) -> bool {
sym.starts_with('_')
}
fn looks_generated_temp_sym(sym: &swc_core::atoms::Atom) -> bool {
is_babel_temp_sym(sym) || sym.chars().any(|ch| ch.is_ascii_digit())
}
#[derive(Default)]
struct BindingReferenceCounter {
references: HashMap<BindingId, usize>,
}
impl Visit for BindingReferenceCounter {
fn visit_ident(&mut self, ident: &Ident) {
let binding_id = (ident.sym.clone(), ident.ctxt);
*self.references.entry(binding_id).or_insert(0) += 1;
}
}
#[cfg(test)]
mod tests {
use swc_core::common::{Globals, SyntaxContext, GLOBALS};
use swc_core::ecma::ast::{AssignExpr, BindingIdent, ExprOrSpread, Null};
use super::*;
fn ident(sym: &str, ctxt: SyntaxContext) -> Ident {
Ident::new(sym.into(), DUMMY_SP, ctxt)
}
fn ident_expr(sym: &str, ctxt: SyntaxContext) -> Expr {
Expr::Ident(ident(sym, ctxt))
}
fn assign_ident_expr(sym: &str, ctxt: SyntaxContext, rhs: Expr) -> Expr {
Expr::Assign(AssignExpr {
span: DUMMY_SP,
op: AssignOp::Assign,
left: AssignTarget::Simple(SimpleAssignTarget::Ident(BindingIdent {
id: ident(sym, ctxt),
type_ann: None,
})),
right: Box::new(rhs),
})
}
fn eq_null(expr: Expr) -> Expr {
Expr::Bin(BinExpr {
span: DUMMY_SP,
op: BinaryOp::EqEqEq,
left: Box::new(expr),
right: Box::new(Expr::Lit(Lit::Null(Null { span: DUMMY_SP }))),
})
}
fn eq_undefined(expr: Expr, unresolved_mark: Mark) -> Expr {
Expr::Bin(BinExpr {
span: DUMMY_SP,
op: BinaryOp::EqEqEq,
left: Box::new(expr),
right: Box::new(ident_expr(
"undefined",
SyntaxContext::empty().apply_mark(unresolved_mark),
)),
})
}
#[test]
fn null_check_assignment_requires_matching_context() {
GLOBALS.set(&Globals::default(), || {
let unresolved_mark = Mark::new();
let first_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
let second_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
let test = Expr::Bin(BinExpr {
span: DUMMY_SP,
op: BinaryOp::LogicalOr,
left: Box::new(eq_null(assign_ident_expr(
"tmp",
first_ctxt,
ident_expr("obj", SyntaxContext::empty()),
))),
right: Box::new(eq_undefined(
ident_expr("tmp", second_ctxt),
unresolved_mark,
)),
});
assert!(extract_null_check(&test, unresolved_mark).is_none());
});
}
#[test]
fn babel_call_context_assignment_requires_matching_context() {
GLOBALS.set(&Globals::default(), || {
let first_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
let second_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
let member_obj =
assign_ident_expr("tmp", first_ctxt, ident_expr("obj", SyntaxContext::empty()));
let context = ident_expr("tmp", second_ctxt);
assert!(recover_babel_call_context(&member_obj, &context).is_none());
});
}
#[test]
fn find_ident_by_binding_requires_matching_context() {
GLOBALS.set(&Globals::default(), || {
let first_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
let second_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
let target = ident("tmp", first_ctxt);
let access = Expr::Call(CallExpr {
span: DUMMY_SP,
ctxt: SyntaxContext::empty(),
callee: Callee::Expr(Box::new(Expr::Member(MemberExpr {
span: DUMMY_SP,
obj: Box::new(ident_expr("tmp", second_ctxt)),
prop: MemberProp::Ident(ident("method", SyntaxContext::empty()).into()),
}))),
args: vec![ExprOrSpread {
spread: None,
expr: Box::new(ident_expr("arg", SyntaxContext::empty())),
}],
type_args: None,
});
assert!(find_ident_by_binding(&access, &target).is_none());
});
}
}