crates/core/src/rules/un_nullish_coalescing.rs

GitHub
use std::collections::{HashMap, HashSet};

use swc_core::common::{Mark, Spanned, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
    AssignExpr, AssignOp, AssignTarget, BinExpr, BinaryOp, Bool, ComputedPropName, CondExpr, Expr,
    Ident, Lit, MemberExpr, MemberProp, Module, SimpleAssignTarget,
};
use swc_core::ecma::utils::ExprFactory;
use swc_core::ecma::visit::{VisitMut, VisitMutWith};

use super::binding_facts::collect_binding_facts;
use super::dead_decls::{extend_consumed_uninitialized_expr, remove_consumed_uninitialized_decls};
use super::decl_utils::BindingId;
pub(crate) use super::expr_utils::{exprs_structurally_equal, is_unresolved_undefined};
use super::{RewriteLevel, RewritePolicy};

use crate::utils::paren::strip_parens;

pub struct UnNullishCoalescing {
    unresolved_mark: Mark,
    policy: RewritePolicy,
    uninitialized_bindings: HashSet<BindingId>,
    binding_references: HashMap<BindingId, usize>,
    consumed_uninitialized_bindings: HashSet<BindingId>,
}

impl UnNullishCoalescing {
    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 UnNullishCoalescing {
    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) {
        expr.visit_mut_children_with(self);

        if let Some(mut result) = try_nullish_coalescing(
            expr,
            self.unresolved_mark,
            self.policy,
            &self.uninitialized_bindings,
            &self.binding_references,
        ) {
            extend_consumed_uninitialized_expr(
                &mut self.consumed_uninitialized_bindings,
                expr,
                &result,
                &self.uninitialized_bindings,
                &self.binding_references,
            );
            if let Expr::Bin(bin) = &mut result {
                bin.span = expr.span();
            }
            *expr = result;
        }
    }
}

fn try_nullish_coalescing(
    expr: &Expr,
    unresolved_mark: Mark,
    policy: RewritePolicy,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    // Temp-backed computed member shape:
    // `(_obj = getObj())[_key = getKey()] ?? (_obj[_key] = fallback)`
    // → `getObj()[getKey()] ??= fallback`.
    //
    // The isolated compiler temps preserve the single evaluation of both the
    // object and key, so this recovery is safe at every rewrite level.
    if let Some(result) = try_temp_backed_computed_member_nullish_assignment(
        expr,
        uninitialized_bindings,
        binding_references,
    ) {
        return Some(result);
    }

    // Native logical assignment shape: `target ?? (target = fallback)` → `target ??= fallback`.
    if let Some(result) = try_nullish_assignment(expr, unresolved_mark, policy) {
        return Some(result);
    }

    // Pattern C: `(tmp = X) === null || tmp === undefined || tmp` → `X ?? true`
    // (||‐chain encoding of nullish coalescing with boolean `true` default)
    if let Some(result) = try_pattern_c_coalescing(
        expr,
        unresolved_mark,
        policy,
        uninitialized_bindings,
        binding_references,
    ) {
        return Some(result);
    }

    let Expr::Cond(cond_expr) = expr else {
        return None;
    };

    // Pattern D: `x != null ? x : fallback` / `x == null ? fallback : x`
    // Temp-var form: `(tmp = expr) != null ? tmp : fallback` -> `expr ?? fallback`
    if policy.assumptions.no_document_all {
        if let Some(result) = try_loose_pattern_coalescing(
            cond_expr,
            unresolved_mark,
            uninitialized_bindings,
            binding_references,
        ) {
            return Some(result);
        }
    }

    // Pattern B: `x === null || x === void 0 ? fallback : x`
    if let Some(result) = try_pattern_b_coalescing(
        cond_expr,
        unresolved_mark,
        uninitialized_bindings,
        binding_references,
    ) {
        return Some(result);
    }

    // Pattern A: `x !== null && x !== void 0 ? x : fallback`
    if let Some(result) = try_pattern_a_coalescing(
        cond_expr,
        unresolved_mark,
        uninitialized_bindings,
        binding_references,
    ) {
        return Some(result);
    }

    None
}

fn try_temp_backed_computed_member_nullish_assignment(
    expr: &Expr,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    let Expr::Bin(BinExpr {
        op: BinaryOp::NullishCoalescing,
        left,
        right,
        ..
    }) = expr
    else {
        return None;
    };

    let Expr::Member(read_member) = strip_parens(left) else {
        return None;
    };
    let (object_sym, object_ctxt, object) = extract_assign_parts(&read_member.obj)?;
    let MemberProp::Computed(read_prop) = &read_member.prop else {
        return None;
    };
    let (key_sym, key_ctxt, key) = extract_assign_parts(&read_prop.expr)?;

    let Expr::Assign(write) = strip_parens(right) else {
        return None;
    };
    if write.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Member(write_member)) = &write.left else {
        return None;
    };
    if !expr_is_ident_binding(&write_member.obj, &object_sym, object_ctxt) {
        return None;
    }
    let MemberProp::Computed(write_prop) = &write_member.prop else {
        return None;
    };
    if !expr_is_ident_binding(&write_prop.expr, &key_sym, key_ctxt) {
        return None;
    }

    // Each temp must occur only in its declaration and the two positions in
    // this pattern (the read-side assignment and write-side identifier).
    if !is_safe_temp_with_total_refs(
        &object_sym,
        object_ctxt,
        uninitialized_bindings,
        binding_references,
        3,
    ) || !is_safe_temp_with_total_refs(
        &key_sym,
        key_ctxt,
        uninitialized_bindings,
        binding_references,
        3,
    ) {
        return None;
    }

    Some(Expr::Assign(AssignExpr {
        span: expr.span(),
        op: AssignOp::NullishAssign,
        left: AssignTarget::Simple(SimpleAssignTarget::Member(MemberExpr {
            span: read_member.span,
            obj: object.clone(),
            prop: MemberProp::Computed(ComputedPropName {
                span: read_prop.span,
                expr: key.clone(),
            }),
        })),
        right: write.right.clone(),
    }))
}

fn expr_is_ident_binding(expr: &Expr, sym: &swc_core::atoms::Atom, ctxt: SyntaxContext) -> bool {
    matches!(strip_parens(expr), Expr::Ident(ident) if ident.sym == *sym && ident.ctxt == ctxt)
}

fn try_nullish_assignment(
    expr: &Expr,
    unresolved_mark: Mark,
    policy: RewritePolicy,
) -> Option<Expr> {
    let Expr::Bin(BinExpr {
        op: BinaryOp::NullishCoalescing,
        left,
        right,
        ..
    }) = expr
    else {
        return None;
    };

    let Expr::Assign(assign) = strip_parens(right) else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }

    if !assign_target_recoverable_as_nullish_assignment(&assign.left, unresolved_mark, policy) {
        return None;
    }
    let left_target_expr = assign_target_to_expr(&assign.left)?;
    if !exprs_structurally_equal(left, &left_target_expr) {
        return None;
    }

    Some(Expr::Assign(AssignExpr {
        span: expr.span(),
        op: AssignOp::NullishAssign,
        left: assign.left.clone(),
        right: assign.right.clone(),
    }))
}

fn assign_target_recoverable_as_nullish_assignment(
    target: &AssignTarget,
    unresolved_mark: Mark,
    policy: RewritePolicy,
) -> bool {
    match target {
        AssignTarget::Simple(SimpleAssignTarget::Ident(id)) => {
            id.id.ctxt.outer() != unresolved_mark || policy.level >= RewriteLevel::Standard
        }
        AssignTarget::Simple(SimpleAssignTarget::Member(member)) => {
            member_recoverable_as_nullish_assignment(member, unresolved_mark, policy)
        }
        _ => false,
    }
}

fn member_recoverable_as_nullish_assignment(
    member: &MemberExpr,
    unresolved_mark: Mark,
    policy: RewritePolicy,
) -> bool {
    if is_static_member_with_local_base(member, unresolved_mark) {
        return policy.level >= RewriteLevel::Standard;
    }

    policy.assumptions.pure_getters && is_member_chain_without_side_effectful_base(member)
}

fn is_static_member_with_local_base(member: &MemberExpr, unresolved_mark: Mark) -> bool {
    matches!(member.obj.as_ref(), Expr::Ident(base) if base.ctxt.outer() != unresolved_mark)
        && matches!(member.prop, MemberProp::Ident(_))
}

fn is_member_chain_without_side_effectful_base(member: &MemberExpr) -> bool {
    if !matches!(member.prop, MemberProp::Ident(_) | MemberProp::Computed(_)) {
        return false;
    }

    match member.obj.as_ref() {
        Expr::Ident(_) | Expr::This(_) => true,
        Expr::Member(base) => is_member_chain_without_side_effectful_base(base),
        _ => false,
    }
}

fn assign_target_to_expr(target: &AssignTarget) -> Option<Expr> {
    match target {
        AssignTarget::Simple(SimpleAssignTarget::Ident(id)) => Some(Expr::Ident(id.id.clone())),
        AssignTarget::Simple(SimpleAssignTarget::Member(member)) => {
            Some(Expr::Member(member.clone()))
        }
        _ => None,
    }
}

fn try_loose_pattern_coalescing(
    cond: &CondExpr,
    unresolved_mark: Mark,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    let Expr::Bin(BinExpr {
        op, left, right, ..
    }) = cond.test.as_ref()
    else {
        return None;
    };

    match op {
        BinaryOp::NotEq => {
            let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
            try_loose_pattern_parts(
                checked,
                &cond.cons,
                cond.alt.clone(),
                uninitialized_bindings,
                binding_references,
            )
        }
        BinaryOp::EqEq => {
            let checked = extract_loose_null_operand(left, right, unresolved_mark)?;
            try_loose_pattern_parts(
                checked,
                &cond.alt,
                cond.cons.clone(),
                uninitialized_bindings,
                binding_references,
            )
        }
        _ => None,
    }
}

fn try_loose_pattern_parts(
    checked: Box<Expr>,
    value_branch: &Expr,
    fallback: Box<Expr>,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    if let Some((tmp_sym, tmp_ctxt, real_rhs)) = extract_assign_parts(&checked) {
        let tmp = Box::new(Expr::Ident(Ident::new(tmp_sym.clone(), DUMMY_SP, tmp_ctxt)));
        if !exprs_structurally_equal(value_branch, &tmp) {
            return None;
        }
        if !is_safe_temp_with_total_refs(
            &tmp_sym,
            tmp_ctxt,
            uninitialized_bindings,
            binding_references,
            3,
        ) {
            return None;
        }
        return Some(make_nullish_coalescing(real_rhs.clone(), fallback));
    }

    if exprs_structurally_equal(value_branch, &checked) {
        return Some(make_nullish_coalescing(checked, fallback));
    }

    None
}

/// Pattern A: `x !== null && x !== void 0 ? x : fallback`  →  `x ?? fallback`
/// Temp-var form: `(tmp = expr) !== null && tmp !== void 0 ? tmp : fallback`  →  `expr ?? fallback`
fn try_pattern_a_coalescing(
    cond: &CondExpr,
    unresolved_mark: Mark,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    let NullCheckResult { value, real_value } =
        extract_not_null_check(&cond.test, unresolved_mark)?;

    // Temp-var form: consequent must equal `tmp` (the variable on the LHS of the assignment)
    if let Some(real) = real_value {
        if exprs_structurally_equal(&cond.cons, &value) {
            if let Expr::Ident(ref tmp_ident) = *value {
                if !is_safe_temp(
                    &tmp_ident.sym,
                    tmp_ident.ctxt,
                    uninitialized_bindings,
                    binding_references,
                ) {
                    return None;
                }
            }
            return Some(make_nullish_coalescing(real, cond.alt.clone()));
        }
        return None;
    }

    // Plain form: consequent must equal the checked value
    if exprs_structurally_equal(&cond.cons, &value) {
        return Some(make_nullish_coalescing(value, cond.alt.clone()));
    }

    None
}

/// Pattern B: `x === null || x === void 0 ? fallback : x`  →  `x ?? fallback`
/// Temp-var form: `(tmp = expr) === null || tmp === void 0 ? fallback : tmp`  →  `expr ?? fallback`
fn try_pattern_b_coalescing(
    cond: &CondExpr,
    unresolved_mark: Mark,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    let NullCheckResult { value, real_value } = extract_null_check(&cond.test, unresolved_mark)?;

    // Temp-var form: alternate must equal `tmp`
    if let Some(real) = real_value {
        if exprs_structurally_equal(&cond.alt, &value) {
            if let Expr::Ident(ref tmp_ident) = *value {
                if !is_safe_temp(
                    &tmp_ident.sym,
                    tmp_ident.ctxt,
                    uninitialized_bindings,
                    binding_references,
                ) {
                    return None;
                }
            }
            return Some(make_nullish_coalescing(real, cond.cons.clone()));
        }
        return None;
    }

    // Plain form: alternate must equal the checked value
    if exprs_structurally_equal(&cond.alt, &value) {
        return Some(make_nullish_coalescing(value, cond.cons.clone()));
    }

    None
}

/// Pattern C: `(tmp = X) === null || tmp === undefined || tmp`  →  `X ?? true`
/// Also handles the plain identifier form: `x === null || x === undefined || x`  →  `x ?? true`
///
/// This is an ||‐chain encoding of nullish coalescing where the default is `true`.
/// When X is null/undefined the `=== null` or `=== undefined` comparison yields `true`
/// (short-circuiting the chain), otherwise the chain falls through to `|| X` itself.
///
/// The plain form with member expressions (`B.broadcast === null || ...`) reads
/// the property up to 3 times, so collapsing to `B.broadcast ?? true` changes
/// semantics for getters, proxies, or values that change between reads. This
/// form requires `Aggressive` level. Plain identifiers may also differ under
/// `with` or global accessor bindings (3 reads → 1), but this is acceptable
/// under Wakaru's heuristic policy for Standard level.
/// The real machine-generated pattern always uses a temp variable.
fn try_pattern_c_coalescing(
    expr: &Expr,
    unresolved_mark: Mark,
    policy: RewritePolicy,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> Option<Expr> {
    // Shape: `(A || B) || C` where A = null-check, B = undefined-check, C = value
    let Expr::Bin(BinExpr {
        op: BinaryOp::LogicalOr,
        left: outer_left,
        right: tail,
        ..
    }) = expr
    else {
        return None;
    };

    // outer_left must be another `||`
    let Expr::Bin(BinExpr {
        op: BinaryOp::LogicalOr,
        left: null_check_expr,
        right: undef_check_expr,
        ..
    }) = outer_left.as_ref()
    else {
        return None;
    };

    // Extract the null-check value (possibly with assignment)
    let null_val = extract_null_single(null_check_expr)?;
    // Extract the undefined-check value
    let undef_val = extract_undefined_single(undef_check_expr, unresolved_mark)?;

    // Check for assignment pattern: null_val may be `(tmp = real_expr)`
    if let Some((tmp_sym, tmp_ctxt, real_rhs)) = extract_assign_parts(&null_val) {
        // undef_check must reference `tmp`
        if let Expr::Ident(ri) = &*undef_val {
            if ri.sym == tmp_sym && ri.ctxt == tmp_ctxt {
                // tail must also be `tmp`
                if let Expr::Ident(ti) = tail.as_ref() {
                    if ti.sym == tmp_sym && ti.ctxt == tmp_ctxt {
                        if !is_safe_temp(
                            &tmp_sym,
                            tmp_ctxt,
                            uninitialized_bindings,
                            binding_references,
                        ) {
                            return None;
                        }
                        return Some(make_nullish_coalescing(
                            real_rhs.clone(),
                            Box::new(Expr::Lit(Lit::Bool(Bool {
                                span: DUMMY_SP,
                                value: true,
                            }))),
                        ));
                    }
                }
            }
        }
        return None;
    }

    // Plain identifier form: identifiers may technically differ under `with` or
    // global accessor bindings (3 reads → 1), but this is acceptable heuristically.
    if matches!(&*null_val, Expr::Ident(_)) && policy.level < RewriteLevel::Standard {
        return None;
    }

    // Member expressions and other complex forms require Aggressive level
    // because collapsing 3 reads into 1 changes semantics for getters/proxies.
    if !matches!(&*null_val, Expr::Ident(_)) && !policy.assumptions.pure_getters {
        return None;
    }

    if !exprs_structurally_equal(&null_val, &undef_val) {
        return None;
    }
    if !exprs_structurally_equal(&null_val, tail) {
        return None;
    }

    Some(make_nullish_coalescing(
        null_val,
        Box::new(Expr::Lit(Lit::Bool(Bool {
            span: DUMMY_SP,
            value: true,
        }))),
    ))
}

/// Result of a null-check extraction.
/// `value` is the expression that was checked (or the tmp var ident if assignment).
/// `real_value` is `Some(rhs)` if the first operand was an assignment `(tmp = rhs)`.
struct NullCheckResult {
    /// The checked expression (ident/member/etc.). For assignment patterns, this is `tmp`.
    value: Box<Expr>,
    /// `Some(rhs)` when the left side of the null check was `(tmp = rhs)`.
    real_value: Option<Box<Expr>>,
}

/// Extract from `x !== null && x !== void 0`.
/// Also handles the assignment form `(tmp = expr) !== null && tmp !== void 0`.
fn extract_not_null_check(expr: &Expr, unresolved_mark: Mark) -> Option<NullCheckResult> {
    let Expr::Bin(BinExpr {
        op: BinaryOp::LogicalAnd,
        left,
        right,
        ..
    }) = expr
    else {
        return None;
    };

    let left_val = extract_not_null_single(left)?;
    let right_val = extract_not_undefined_single(right, unresolved_mark)?;

    // Check for assignment pattern: left_val may be `(tmp = real_expr)`
    if let Some((tmp_sym, tmp_ctxt, real_rhs)) = extract_assign_parts(&left_val) {
        // right side must reference `tmp`
        if let Expr::Ident(ri) = &*right_val {
            if ri.sym == tmp_sym && ri.ctxt == tmp_ctxt {
                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`.
/// Also handles the 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)?;

    // Check for assignment pattern: left_val may be `(tmp = real_expr)`
    if let Some((tmp_sym, tmp_ctxt, real_rhs)) = extract_assign_parts(&left_val) {
        // right side must reference `tmp`
        if let Expr::Ident(ri) = &*right_val {
            if ri.sym == tmp_sym && ri.ctxt == tmp_ctxt {
                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,
    })
}

/// Match `x !== null` or `null !== x` — return x.
fn extract_not_null_single(expr: &Expr) -> Option<Box<Expr>> {
    let Expr::Bin(BinExpr {
        op, left, right, ..
    }) = expr
    else {
        return None;
    };
    if !matches!(op, BinaryOp::NotEqEq | BinaryOp::NotEq) {
        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_loose_null_operand(
    left: &Expr,
    right: &Expr,
    unresolved_mark: Mark,
) -> Option<Box<Expr>> {
    if matches!(right, Expr::Lit(Lit::Null(_))) || is_unresolved_undefined(right, unresolved_mark) {
        return Some(Box::new(left.clone()));
    }
    if matches!(left, Expr::Lit(Lit::Null(_))) || is_unresolved_undefined(left, unresolved_mark) {
        return Some(Box::new(right.clone()));
    }
    None
}

/// Match `x !== void 0` or `x !== undefined` or flipped — return x.
fn extract_not_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::NotEqEq | BinaryOp::NotEq) {
        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
}

/// Match `x === null` or `null === x` — return x.
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
}

/// Match `x === void 0` or `x === undefined` or flipped — return x.
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
}

/// If `expr` is `(tmp = real_expr)` (parens allowed), return `(tmp_sym, tmp_ctxt, &real_expr)`.
fn extract_assign_parts(expr: &Expr) -> Option<(swc_core::atoms::Atom, SyntaxContext, &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.sym.clone(), id.id.ctxt, &assign.right))
}

fn make_nullish_coalescing(value: Box<Expr>, fallback: Box<Expr>) -> Expr {
    (*value).make_bin(BinaryOp::NullishCoalescing, *fallback)
}

/// Check that a temp variable has a known uninitialized declaration (`var tmp;`
/// or `let tmp;`) and is only referenced within the pattern itself plus that
/// declaration. The temp appears 3 times in the pattern (assignment target +
/// 2 uses) and 1 time in the declaration, for a total of 4.
///
/// Without a known declaration the temp is either an undeclared global (sloppy
/// mode: erasing the assignment drops a global side effect) or an unresolved
/// binding (strict/module mode: the original throws `ReferenceError` but the
/// rewrite would not). Both cases are unsafe to erase.
fn is_safe_temp(
    sym: &swc_core::atoms::Atom,
    ctxt: SyntaxContext,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
) -> bool {
    is_safe_temp_with_total_refs(sym, ctxt, uninitialized_bindings, binding_references, 4)
}

fn is_safe_temp_with_total_refs(
    sym: &swc_core::atoms::Atom,
    ctxt: SyntaxContext,
    uninitialized_bindings: &HashSet<BindingId>,
    binding_references: &HashMap<BindingId, usize>,
    expected_total_refs: usize,
) -> bool {
    let binding_id = (sym.clone(), ctxt);
    if !uninitialized_bindings.contains(&binding_id) {
        return false;
    }
    let total_refs = binding_references.get(&binding_id).copied().unwrap_or(0);
    total_refs == expected_total_refs
}

#[cfg(test)]
mod tests {
    use super::*;
    use swc_core::common::{Mark, DUMMY_SP, GLOBALS};
    use swc_core::ecma::ast::{ComputedPropName, Ident, MemberProp};

    fn ident(sym: &str, ctxt: SyntaxContext) -> Expr {
        Expr::Ident(Ident::new(sym.into(), DUMMY_SP, ctxt))
    }

    #[test]
    fn structural_expr_equality_distinguishes_identifier_contexts() {
        GLOBALS.set(&Default::default(), || {
            let first_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
            let second_ctxt = SyntaxContext::empty().apply_mark(Mark::new());

            assert!(exprs_structurally_equal(
                &ident("tmp", first_ctxt),
                &ident("tmp", first_ctxt)
            ));
            assert!(!exprs_structurally_equal(
                &ident("tmp", first_ctxt),
                &ident("tmp", second_ctxt)
            ));
        });
    }

    #[test]
    fn structural_member_equality_distinguishes_computed_identifier_contexts() {
        GLOBALS.set(&Default::default(), || {
            let first_ctxt = SyntaxContext::empty().apply_mark(Mark::new());
            let second_ctxt = SyntaxContext::empty().apply_mark(Mark::new());

            let first = Expr::Member(swc_core::ecma::ast::MemberExpr {
                span: DUMMY_SP,
                obj: Box::new(ident("obj", SyntaxContext::empty())),
                prop: MemberProp::Computed(ComputedPropName {
                    span: DUMMY_SP,
                    expr: Box::new(ident("key", first_ctxt)),
                }),
            });
            let second = Expr::Member(swc_core::ecma::ast::MemberExpr {
                span: DUMMY_SP,
                obj: Box::new(ident("obj", SyntaxContext::empty())),
                prop: MemberProp::Computed(ComputedPropName {
                    span: DUMMY_SP,
                    expr: Box::new(ident("key", second_ctxt)),
                }),
            });

            assert!(!exprs_structurally_equal(&first, &second));
        });
    }
}