crates/core/src/rules/un_destructuring.rs

GitHub
use std::collections::HashSet;

use swc_core::atoms::Atom;
use swc_core::common::{Mark, Span, Spanned, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
    ArrayPat, AssignExpr, AssignOp, AssignPat, AssignPatProp, AssignTarget, AssignTargetPat,
    BinaryOp, BindingIdent, BlockStmt, Bool, Callee, CondExpr, Decl, Expr, ExprOrSpread, ExprStmt,
    Function, Ident, IdentName, KeyValuePatProp, Lit, MemberExpr, MemberProp, Module, ModuleItem,
    Number, ObjectPat, ObjectPatProp, Param, Pat, PropName, RestPat, SimpleAssignTarget, Stmt,
    VarDecl, VarDeclKind, VarDeclarator,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};

use super::decl_utils::{
    can_remove_prior_uninitialized_decls_by, remove_prior_uninitialized_decls_by,
    UninitializedDeclKind,
};
use super::helper_matcher::{binding_key, BindingKey};
use super::transpiler_helper_utils::{LocalHelperContext, TranspilerHelperKind, TsHelperKind};
use super::{expr_utils::is_unresolved_undefined, RewriteLevel};
use crate::utils::paren::strip_parens;

/// Reconstructs destructuring from compiler-lowered ref/temp declarations.
///
/// This rule intentionally targets the shape emitted by transforms like SWC's
/// es2015 destructuring pass, rather than guessing from arbitrary property
/// reads. `SmartInline` remains the later readability heuristic for simpler
/// adjacent accesses.
pub struct UnDestructuring {
    unresolved_mark: Mark,
    level: RewriteLevel,
    sliced_to_array_helpers: Option<HashSet<BindingKey>>,
    consumed_sliced_to_array_helpers: HashSet<BindingKey>,
}

impl UnDestructuring {
    pub fn new(unresolved_mark: Mark) -> Self {
        Self::new_with_level(unresolved_mark, RewriteLevel::Standard)
    }

    pub fn new_with_level(unresolved_mark: Mark, level: RewriteLevel) -> Self {
        Self {
            unresolved_mark,
            level,
            sliced_to_array_helpers: None,
            consumed_sliced_to_array_helpers: HashSet::new(),
        }
    }

    pub(crate) fn new_with_helpers(
        unresolved_mark: Mark,
        level: RewriteLevel,
        local_helpers: &LocalHelperContext,
    ) -> Self {
        Self {
            unresolved_mark,
            level,
            sliced_to_array_helpers: Some(collect_sliced_to_array_helpers(local_helpers)),
            consumed_sliced_to_array_helpers: HashSet::new(),
        }
    }

    pub(crate) fn consumed_sliced_to_array_helpers(&self) -> HashSet<BindingKey> {
        self.consumed_sliced_to_array_helpers.clone()
    }
}

#[derive(Clone)]
struct RefDecl {
    span: swc_core::common::Span,
    ctxt: swc_core::common::SyntaxContext,
    kind: VarDeclKind,
    declare: bool,
    ident: BindingIdent,
    init: Box<Expr>,
}

#[derive(Clone)]
enum Access {
    Array { index: usize, pat: Pat },
    ArrayRest { start: usize, binding: BindingIdent },
    Object { key: PropKey, pat: Pat },
}

#[derive(Clone)]
enum SourceAccess {
    ArrayIndex(usize),
    ObjectProp(PropKey),
}

#[derive(Clone)]
enum PropKey {
    Ident(Atom),
    Str(Atom),
}

impl VisitMut for UnDestructuring {
    fn visit_mut_module(&mut self, module: &mut Module) {
        if self.sliced_to_array_helpers.is_none() {
            let local_helpers = LocalHelperContext::collect_with_mark(module, self.unresolved_mark);
            self.sliced_to_array_helpers = Some(collect_sliced_to_array_helpers(&local_helpers));
        }
        module.visit_mut_children_with(self);
        let (items, consumed_helpers) = process_module_items(
            std::mem::take(&mut module.body),
            self.unresolved_mark,
            self.level,
            self.sliced_to_array_helpers(),
        );
        self.consumed_sliced_to_array_helpers
            .extend(consumed_helpers);
        module.body = items;
    }

    fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
        stmts.visit_mut_children_with(self);
        let (processed, consumed_helpers) = process_stmts(
            std::mem::take(stmts),
            self.unresolved_mark,
            self.level,
            self.sliced_to_array_helpers(),
        );
        self.consumed_sliced_to_array_helpers
            .extend(consumed_helpers);
        *stmts = processed;
    }

    fn visit_mut_function(&mut self, func: &mut Function) {
        func.visit_mut_children_with(self);
        if self.level >= RewriteLevel::Standard {
            if let Some(body) = &mut func.body {
                nest_param_destructuring(&mut func.params, body, self.unresolved_mark);
            }
        }
    }
}

impl UnDestructuring {
    fn sliced_to_array_helpers(&self) -> &HashSet<BindingKey> {
        self.sliced_to_array_helpers
            .as_ref()
            .expect("UnDestructuring should collect helper facts before visiting statements")
    }
}

fn collect_sliced_to_array_helpers(local_helpers: &LocalHelperContext) -> HashSet<BindingKey> {
    let mut helpers: HashSet<_> = local_helpers
        .helpers_of_kind(TranspilerHelperKind::SlicedToArray)
        .keys()
        .cloned()
        .collect();
    helpers.extend(local_helpers.ts_helpers_of_kind(TsHelperKind::Read));
    helpers
}

fn process_module_items(
    items: Vec<ModuleItem>,
    unresolved_mark: Mark,
    level: RewriteLevel,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> (Vec<ModuleItem>, Vec<BindingKey>) {
    let mut result = Vec::with_capacity(items.len());
    let mut stmt_buf = Vec::new();
    let mut consumed_sliced_to_array_helpers = Vec::new();

    for item in items {
        match item {
            ModuleItem::Stmt(stmt) => stmt_buf.push(stmt),
            other => {
                if !stmt_buf.is_empty() {
                    let (processed, consumed_helpers) = process_stmts(
                        std::mem::take(&mut stmt_buf),
                        unresolved_mark,
                        level,
                        sliced_to_array_helpers,
                    );
                    consumed_sliced_to_array_helpers.extend(consumed_helpers);
                    result.extend(processed.into_iter().map(ModuleItem::Stmt));
                }
                result.push(other);
            }
        }
    }

    if !stmt_buf.is_empty() {
        let (processed, consumed_helpers) =
            process_stmts(stmt_buf, unresolved_mark, level, sliced_to_array_helpers);
        consumed_sliced_to_array_helpers.extend(consumed_helpers);
        result.extend(processed.into_iter().map(ModuleItem::Stmt));
    }

    (result, consumed_sliced_to_array_helpers)
}

fn process_stmts(
    stmts: Vec<Stmt>,
    unresolved_mark: Mark,
    level: RewriteLevel,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> (Vec<Stmt>, Vec<BindingKey>) {
    let mut stmts = hoist_conditional_test_assignments(stmts);
    let mut result = Vec::with_capacity(stmts.len());
    let mut consumed_helpers: Vec<BindingKey> = Vec::new();
    let mut i = 0;

    while i < stmts.len() {
        if let Some(group) = try_reconstruct_group(
            &stmts,
            i,
            unresolved_mark,
            level,
            sliced_to_array_helpers,
            &mut consumed_helpers,
        ) {
            remove_prior_uninitialized_decls_for_bindings(
                &mut result,
                &group.remove_prior_bindings,
            );
            result.push(group.stmt);
            i += group.consumed;
        } else {
            result.push(std::mem::replace(
                &mut stmts[i],
                Stmt::Empty(swc_core::ecma::ast::EmptyStmt {
                    span: swc_core::common::DUMMY_SP,
                }),
            ));
            i += 1;
        }
    }

    if !consumed_helpers.is_empty() {
        remove_unreferenced_helpers(&mut result, &consumed_helpers);
    }

    let consumed_sliced_to_array_helpers = consumed_helpers
        .iter()
        .filter(|key| sliced_to_array_helpers.contains(*key))
        .cloned()
        .collect();

    (result, consumed_sliced_to_array_helpers)
}

struct ReconstructedGroup {
    stmt: Stmt,
    consumed: usize,
    remove_prior_bindings: Vec<BindingKey>,
}

fn remove_prior_uninitialized_decls_for_bindings(stmts: &mut Vec<Stmt>, bindings: &[BindingKey]) {
    let removable: Vec<_> = bindings
        .iter()
        .map(|(sym, ctxt)| Ident::new(sym.clone(), DUMMY_SP, *ctxt))
        .filter(|target| {
            can_remove_prior_uninitialized_decls_by(
                stmts,
                std::slice::from_ref(target),
                UninitializedDeclKind::Any,
                same_binding_ident,
            )
        })
        .collect();

    if removable.is_empty() {
        return;
    }

    remove_prior_uninitialized_decls_by(
        stmts,
        stmts.len(),
        &removable,
        UninitializedDeclKind::Any,
        same_binding_ident,
    );
}

fn same_binding_ident(left: &Ident, right: &Ident) -> bool {
    left.sym == right.sym && left.ctxt == right.ctxt
}

/// Un-fuses minifier output that inlined an array/object extraction into the
/// test of a conditional, e.g. `_f = (backup = _e[2]) != null ? backup : y`.
/// The embedded `backup = _e[2]` assignment is hoisted to its own preceding
/// statement so the surrounding destructuring group can pick it up. Restricted
/// to member-access right-hand sides so it only targets the extraction pattern.
fn hoist_conditional_test_assignments(stmts: Vec<Stmt>) -> Vec<Stmt> {
    let mut result = Vec::with_capacity(stmts.len());
    for mut stmt in stmts {
        if let Some(hoisted) = take_hoistable_cond_test_assignment(&mut stmt) {
            result.push(hoisted);
        }
        result.push(stmt);
    }
    result
}

fn take_hoistable_cond_test_assignment(stmt: &mut Stmt) -> Option<Stmt> {
    let (outer_target, cond) = cond_value_of_stmt_mut(stmt)?;
    let Expr::Bin(bin) = cond.test.as_mut() else {
        return None;
    };
    if !matches!(
        bin.op,
        BinaryOp::EqEq | BinaryOp::NotEq | BinaryOp::EqEqEq | BinaryOp::NotEqEq
    ) {
        return None;
    }
    if let Some(hoisted) = take_member_assign_operand(&mut bin.left, &outer_target) {
        return Some(hoisted);
    }
    take_member_assign_operand(&mut bin.right, &outer_target)
}

/// Returns the statement's outer assignment target (if any) and a mutable
/// reference to a conditional it assigns/initializes.
fn cond_value_of_stmt_mut(stmt: &mut Stmt) -> Option<(Option<BindingKey>, &mut CondExpr)> {
    match stmt {
        Stmt::Expr(ExprStmt { expr, .. }) => match expr.as_mut() {
            Expr::Assign(assign) if assign.op == AssignOp::Assign => {
                let target = match &assign.left {
                    AssignTarget::Simple(SimpleAssignTarget::Ident(id)) => {
                        Some(binding_key(&id.id))
                    }
                    _ => None,
                };
                match assign.right.as_mut() {
                    Expr::Cond(cond) => Some((target, cond)),
                    _ => None,
                }
            }
            Expr::Cond(cond) => Some((None, cond)),
            _ => None,
        },
        Stmt::Decl(Decl::Var(var)) if var.decls.len() == 1 => {
            let target = match &var.decls[0].name {
                Pat::Ident(id) => Some(binding_key(&id.id)),
                _ => None,
            };
            match var.decls[0].init.as_deref_mut()? {
                Expr::Cond(cond) => Some((target, cond)),
                _ => None,
            }
        }
        _ => None,
    }
}

/// If `operand` is `ident = <member-access>`, replace it with `ident` and
/// return the hoisted `ident = <member-access>;` statement. Skips the minifier
/// self-assign idiom (`o = (o = x.y) != null ? ...`) where the inner target
/// matches the outer one — there is no destructuring element to recover there.
fn take_member_assign_operand(
    operand: &mut Box<Expr>,
    outer_target: &Option<BindingKey>,
) -> Option<Stmt> {
    let Expr::Assign(assign) = strip_parens(operand.as_ref()) else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Ident(ident)) = &assign.left else {
        return None;
    };
    // Only an extraction from a destructuring source: `ident = <obj>.<m>` where
    // `<obj>` is a binding (`Z`) or an inline-established one (`(V = …)`).
    // Excludes `ident = (a ?? {}).p` / `ident = a.b.c` where no destructuring
    // group can form, which would split statements for no benefit.
    let Expr::Member(member) = strip_parens(assign.right.as_ref()) else {
        return None;
    };
    if !matches!(
        strip_parens(member.obj.as_ref()),
        Expr::Ident(_) | Expr::Assign(_)
    ) {
        return None;
    }
    if outer_target
        .as_ref()
        .is_some_and(|target| *target == binding_key(&ident.id))
    {
        return None;
    }
    let hoisted = Stmt::Expr(ExprStmt {
        span: assign.span,
        expr: Box::new(Expr::Assign(assign.clone())),
    });
    **operand = Expr::Ident(ident.id.clone());
    Some(hoisted)
}

fn try_reconstruct_group(
    stmts: &[Stmt],
    start: usize,
    unresolved_mark: Mark,
    level: RewriteLevel,
    sliced_to_array_helpers: &HashSet<BindingKey>,
    consumed_helpers: &mut Vec<BindingKey>,
) -> Option<ReconstructedGroup> {
    let mut group_helpers = Vec::new();
    if let Some(group) = try_reconstruct_assignment_group(
        stmts,
        start,
        unresolved_mark,
        sliced_to_array_helpers,
        &mut group_helpers,
    ) {
        consumed_helpers.extend(group_helpers);
        return Some(group);
    }

    let mut group_helpers = Vec::new();
    if let Some(group) =
        try_reconstruct_ref_group(stmts, start, unresolved_mark, &mut group_helpers)
    {
        consumed_helpers.extend(group_helpers);
        return Some(group);
    }

    (level >= RewriteLevel::Aggressive)
        .then(|| try_reconstruct_direct_array_group(stmts, start, unresolved_mark))
        .flatten()
}

fn try_reconstruct_assignment_group(
    stmts: &[Stmt],
    start: usize,
    unresolved_mark: Mark,
    sliced_to_array_helpers: &HashSet<BindingKey>,
    consumed_helpers: &mut Vec<BindingKey>,
) -> Option<ReconstructedGroup> {
    let first = try_extract_assignment_access(
        stmts,
        start,
        None,
        unresolved_mark,
        sliced_to_array_helpers,
    )?;
    let source = first.source;
    let init = first.init;
    let mut accesses = vec![first.access];
    let mut removed_temps = first.removed_temps;
    let mut matched_helpers = first.consumed_helpers;

    let mut i = start + first.consumed;
    while i < stmts.len() {
        if let Some(next) = try_extract_assignment_access(
            stmts,
            i,
            Some(&source),
            unresolved_mark,
            sliced_to_array_helpers,
        ) {
            accesses.push(next.access);
            removed_temps.extend(next.removed_temps);
            matched_helpers.extend(next.consumed_helpers);
            i += next.consumed;
        } else {
            break;
        }
    }

    if accesses.is_empty() || !accesses.iter().any(is_rest_or_default_access) {
        return None;
    }

    if accesses
        .iter()
        .any(|access| default_uses_any_removed_binding(access, &removed_temps))
    {
        return None;
    }

    for temp in &removed_temps {
        if ident_used_in_stmts(&stmts[i..], temp) {
            return None;
        }
    }

    let first_span = stmts[start].span();
    let stmt = build_assignment_destructuring_stmt(first_span, accesses, init)?;
    consumed_helpers.extend(matched_helpers);
    Some(ReconstructedGroup {
        stmt,
        consumed: i - start,
        remove_prior_bindings: removed_temps,
    })
}

struct AssignmentAccess {
    source: Ident,
    init: Box<Expr>,
    access: Access,
    consumed: usize,
    removed_temps: Vec<BindingKey>,
    consumed_helpers: Vec<BindingKey>,
}

fn try_extract_assignment_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    unresolved_mark: Mark,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> Option<AssignmentAccess> {
    if let Some(extracted) = try_extract_assignment_sliced_default_access(
        stmts,
        index,
        expected_source,
        unresolved_mark,
        sliced_to_array_helpers,
    ) {
        return Some(extracted);
    }

    if let Some(extracted) =
        try_extract_assignment_member_default_access(stmts, index, expected_source, unresolved_mark)
    {
        return Some(extracted);
    }

    if let Some(extracted) = try_extract_assignment_fused_default_access(
        stmts,
        index,
        expected_source,
        unresolved_mark,
        sliced_to_array_helpers,
    ) {
        return Some(extracted);
    }

    if let Some(mut extracted) =
        try_extract_assignment_default_access(stmts, index, expected_source, unresolved_mark)
    {
        if let Some((nested_pat, extra, consumed_helpers)) = try_nest_assignment_default_binding(
            &extracted.access,
            stmts,
            index + extracted.consumed,
            unresolved_mark,
            &mut extracted.removed_temps,
            sliced_to_array_helpers,
        ) {
            replace_access_left(&mut extracted.access, nested_pat);
            extracted.consumed += extra;
            extracted.consumed_helpers.extend(consumed_helpers);
        }
        return Some(extracted);
    }

    let (binding, init) = extract_binding_assignment(stmts.get(index)?)?;
    let (source, source_init, source_access) =
        extract_assignment_source_access(init, expected_source)?;
    let access = match source_access {
        SourceAccess::ArrayIndex(index) => Access::Array {
            index,
            pat: Pat::Ident(binding),
        },
        SourceAccess::ObjectProp(key) => Access::Object {
            key,
            pat: Pat::Ident(binding),
        },
    };

    Some(AssignmentAccess {
        source,
        init: source_init,
        access,
        consumed: 1,
        removed_temps: Vec::new(),
        consumed_helpers: Vec::new(),
    })
}

fn try_extract_assignment_member_default_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    unresolved_mark: Mark,
) -> Option<AssignmentAccess> {
    let (temp, temp_init) = extract_binding_assignment(stmts.get(index)?)?;
    let (source, source_init, source_access) =
        extract_assignment_source_access(temp_init, expected_source)?;

    let (binding, binding_init) = extract_binding_assignment(stmts.get(index + 1)?)?;
    let (default, nested_source_access) =
        extract_default_member_access(binding_init, &temp.id, unresolved_mark)?;
    let temp_key = binding_key(&temp.id);
    if expr_uses_ident(&default, &temp_key) {
        return None;
    }

    let nested_access = match nested_source_access {
        SourceAccess::ArrayIndex(index) => Access::Array {
            index,
            pat: Pat::Ident(binding),
        },
        SourceAccess::ObjectProp(key) => Access::Object {
            key,
            pat: Pat::Ident(binding),
        },
    };
    let nested_pat = build_pat_from_accesses(vec![nested_access])?;
    let pat = Pat::Assign(AssignPat {
        span: DUMMY_SP,
        left: Box::new(nested_pat),
        right: default,
    });

    let access = match source_access {
        SourceAccess::ArrayIndex(index) => Access::Array { index, pat },
        SourceAccess::ObjectProp(key) => Access::Object { key, pat },
    };

    Some(AssignmentAccess {
        source,
        init: source_init,
        access,
        consumed: 2,
        removed_temps: vec![temp_key],
        consumed_helpers: Vec::new(),
    })
}

fn try_extract_assignment_sliced_default_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    unresolved_mark: Mark,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> Option<AssignmentAccess> {
    let (temp, temp_init) = extract_binding_assignment(stmts.get(index)?)?;
    let (source, source_init, source_access) =
        extract_assignment_source_access(temp_init, expected_source)?;

    let (ref_binding, ref_init) = extract_binding_assignment(stmts.get(index + 1)?)?;
    let Expr::Call(call) = strip_parens(ref_init) else {
        return None;
    };
    let Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let helper_key = sliced_to_array_callee_binding(callee.as_ref(), sliced_to_array_helpers)?;
    if call.args.len() != 2 {
        return None;
    }
    let (default, fused_temp) =
        extract_sliced_default_arg(call.args[0].expr.as_ref(), &temp.id, unresolved_mark)?;

    let temp_key = binding_key(&temp.id);
    let ref_key = binding_key(&ref_binding.id);
    if expr_uses_ident(&default, &temp_key) {
        return None;
    }

    let mut removed_temps = vec![temp_key, ref_key];
    removed_temps.extend(fused_temp.map(|id| binding_key(&id)));
    let collected = collect_assignment_accesses_on(
        stmts,
        index + 2,
        &ref_binding.id,
        unresolved_mark,
        &mut removed_temps,
        sliced_to_array_helpers,
    );
    if collected.accesses.is_empty() {
        return None;
    }

    let nested_pat = build_pat_from_accesses(collected.accesses)?;
    let pat = Pat::Assign(AssignPat {
        span: DUMMY_SP,
        left: Box::new(nested_pat),
        right: default,
    });
    let access = match source_access {
        SourceAccess::ArrayIndex(index) => Access::Array { index, pat },
        SourceAccess::ObjectProp(key) => Access::Object { key, pat },
    };

    Some(AssignmentAccess {
        source,
        init: source_init,
        access,
        consumed: 2 + collected.consumed,
        removed_temps,
        consumed_helpers: {
            let mut helpers = vec![helper_key];
            helpers.extend(collected.consumed_helpers);
            helpers
        },
    })
}

/// Handles the minifier-fused form where the defaulted temp is assigned inline
/// inside the first sub-access:
/// `b = src.key; first = (ref = b === undefined ? DEFAULT : b).<m>; … = ref[…]`
/// recovering `key: <nested-pat> = DEFAULT`. Covers both nested object members
/// and array indices (with holes) on the shared `ref` binding.
fn try_extract_assignment_fused_default_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    unresolved_mark: Mark,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> Option<AssignmentAccess> {
    let (temp, temp_init) = extract_binding_assignment(stmts.get(index)?)?;
    let (source, source_init, source_access) =
        extract_assignment_source_access(temp_init, expected_source)?;

    // `first = (ref = temp === undefined ? DEFAULT : temp).<member|[idx]>`
    let (first_binding, first_init) = extract_binding_assignment(stmts.get(index + 1)?)?;
    let Expr::Member(member) = strip_parens(first_init) else {
        return None;
    };
    let Expr::Assign(ref_assign) = strip_parens(member.obj.as_ref()) else {
        return None;
    };
    if ref_assign.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Ident(ref_binding)) = &ref_assign.left else {
        return None;
    };
    let default = extract_default_value(
        strip_parens(ref_assign.right.as_ref()),
        &temp.id,
        unresolved_mark,
    )?;
    let temp_key = binding_key(&temp.id);
    if expr_uses_ident(&default, &temp_key) {
        return None;
    }
    let ref_key = binding_key(&ref_binding.id);

    let first_access = match source_access_from_member_prop(&member.prop)? {
        SourceAccess::ObjectProp(key) => Access::Object {
            key,
            pat: Pat::Ident(first_binding),
        },
        SourceAccess::ArrayIndex(idx) => Access::Array {
            index: idx,
            pat: Pat::Ident(first_binding),
        },
    };

    let mut accesses = vec![first_access];
    let mut removed_temps = vec![temp_key, ref_key.clone()];
    let collected = collect_assignment_accesses_on(
        stmts,
        index + 2,
        &ref_binding.id,
        unresolved_mark,
        &mut removed_temps,
        sliced_to_array_helpers,
    );
    let consumed = 2 + collected.consumed;
    accesses.extend(collected.accesses);

    // The shared `ref` binding must be fully consumed by this group.
    if ident_used_in_stmts(&stmts[index + consumed..], &ref_key) {
        return None;
    }

    let nested_pat = build_pat_from_accesses(accesses)?;
    let pat = Pat::Assign(AssignPat {
        span: DUMMY_SP,
        left: Box::new(nested_pat),
        right: default,
    });
    let access = match source_access {
        SourceAccess::ArrayIndex(idx) => Access::Array { index: idx, pat },
        SourceAccess::ObjectProp(key) => Access::Object { key, pat },
    };

    Some(AssignmentAccess {
        source,
        init: source_init,
        access,
        consumed,
        removed_temps,
        consumed_helpers: collected.consumed_helpers,
    })
}

fn try_extract_assignment_default_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    unresolved_mark: Mark,
) -> Option<AssignmentAccess> {
    let (temp, temp_init) = extract_binding_assignment(stmts.get(index)?)?;
    let (source, source_init, source_access) =
        extract_assignment_source_access(temp_init, expected_source)?;

    let (binding, binding_init) = extract_binding_assignment(stmts.get(index + 1)?)?;
    let default = extract_default_value(binding_init, &temp.id, unresolved_mark)?;
    let temp_key = binding_key(&temp.id);
    if expr_uses_ident(&default, &temp_key) {
        return None;
    }

    let pat = Pat::Assign(AssignPat {
        span: DUMMY_SP,
        left: Box::new(Pat::Ident(binding)),
        right: default,
    });

    let access = match source_access {
        SourceAccess::ArrayIndex(index) => Access::Array { index, pat },
        SourceAccess::ObjectProp(key) => Access::Object { key, pat },
    };

    Some(AssignmentAccess {
        source,
        init: source_init,
        access,
        consumed: 2,
        removed_temps: vec![temp_key],
        consumed_helpers: Vec::new(),
    })
}

fn try_nest_assignment_default_binding(
    access: &Access,
    stmts: &[Stmt],
    nested_start: usize,
    unresolved_mark: Mark,
    removed_temps: &mut Vec<BindingKey>,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> Option<(Pat, usize, Vec<BindingKey>)> {
    let default_binding = match access {
        Access::Object { pat, .. } | Access::Array { pat, .. } => {
            let Pat::Assign(assign) = pat else {
                return None;
            };
            let Pat::Ident(binding) = assign.left.as_ref() else {
                return None;
            };
            &binding.id
        }
        Access::ArrayRest { .. } => return None,
    };

    let collected = collect_assignment_accesses_on(
        stmts,
        nested_start,
        default_binding,
        unresolved_mark,
        removed_temps,
        sliced_to_array_helpers,
    );

    if collected.accesses.is_empty() {
        return None;
    }

    let after_nested = nested_start + collected.consumed;
    let nested_key = binding_key(default_binding);
    if ident_used_in_stmts(&stmts[after_nested..], &nested_key) {
        return None;
    }

    removed_temps.push(nested_key);
    let nested_pat = build_pat_from_accesses(collected.accesses)?;
    Some((nested_pat, collected.consumed, collected.consumed_helpers))
}

fn collect_assignment_accesses_on(
    stmts: &[Stmt],
    start: usize,
    ref_ident: &Ident,
    unresolved_mark: Mark,
    removed_temps: &mut Vec<BindingKey>,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> CollectedAccesses {
    let mut accesses = Vec::new();
    let mut consumed_helpers = Vec::new();
    let mut i = start;

    while i < stmts.len() {
        if let Some(extracted) = try_extract_assignment_access(
            stmts,
            i,
            Some(ref_ident),
            unresolved_mark,
            sliced_to_array_helpers,
        ) {
            accesses.push(extracted.access);
            removed_temps.extend(extracted.removed_temps);
            consumed_helpers.extend(extracted.consumed_helpers);
            i += extracted.consumed;
        } else if let Some((nested, consumed, helpers)) = try_expand_sliced_to_array_accesses(
            stmts,
            i,
            ref_ident,
            unresolved_mark,
            removed_temps,
            sliced_to_array_helpers,
        ) {
            accesses.extend(nested);
            consumed_helpers.extend(helpers);
            i += consumed;
        } else {
            break;
        }
    }

    CollectedAccesses {
        accesses,
        consumed: i - start,
        consumed_helpers,
    }
}

/// When we encounter `ref = _slicedToArray(expected_source, N)` followed by
/// `binding = ref[i]` assignments, expand the `_slicedToArray` transparently:
/// collect the index accesses on `ref` and return them as direct array accesses
/// on `expected_source`. This lets `UnDestructuring` fold
/// `tags: temp = []; ref = _slicedToArray(temp, 3); a = ref[0]; c = ref[2]`
/// into `tags: [a, , c] = []`.
fn try_expand_sliced_to_array_accesses(
    stmts: &[Stmt],
    index: usize,
    expected_source: &Ident,
    unresolved_mark: Mark,
    removed_temps: &mut Vec<BindingKey>,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> Option<(Vec<Access>, usize, Vec<BindingKey>)> {
    let (ref_binding, ref_init) = extract_binding_assignment(stmts.get(index)?)?;
    let Expr::Call(call) = strip_parens(ref_init) else {
        return None;
    };
    let Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let helper_key = sliced_to_array_callee_binding(callee.as_ref(), sliced_to_array_helpers)?;
    if call.args.len() != 2 {
        return None;
    }
    let source_arg = strip_parens(call.args[0].expr.as_ref());
    let Expr::Ident(source_ident) = source_arg else {
        return None;
    };
    if source_ident.sym != expected_source.sym || source_ident.ctxt != expected_source.ctxt {
        return None;
    }

    let ref_key = binding_key(&ref_binding.id);
    removed_temps.push(ref_key);
    let collected = collect_assignment_accesses_on(
        stmts,
        index + 1,
        &ref_binding.id,
        unresolved_mark,
        removed_temps,
        sliced_to_array_helpers,
    );
    if collected.accesses.is_empty() {
        return None;
    }
    let after = index + 1 + collected.consumed;
    if ident_used_in_stmts(&stmts[after..], &binding_key(&ref_binding.id)) {
        return None;
    }
    let mut helpers = vec![helper_key];
    helpers.extend(collected.consumed_helpers);
    Some((collected.accesses, 1 + collected.consumed, helpers))
}

fn try_reconstruct_ref_group(
    stmts: &[Stmt],
    start: usize,
    unresolved_mark: Mark,
    consumed_helpers: &mut Vec<BindingKey>,
) -> Option<ReconstructedGroup> {
    let ref_decl = extract_ref_decl(stmts.get(start)?)?;
    let ref_key = binding_key(&ref_decl.ident.id);

    let mut removed_temps = Vec::new();
    let collected = collect_accesses_on(
        stmts,
        start + 1,
        &ref_decl.ident.id,
        unresolved_mark,
        &mut removed_temps,
        consumed_helpers,
    );

    if collected.accesses.is_empty() {
        return None;
    }
    if !collected.accesses.iter().any(is_rest_or_default_access) {
        return None;
    }

    let i = start + 1 + collected.consumed;

    let mut removed_bindings = vec![ref_key.clone()];
    removed_bindings.extend(removed_temps.iter().cloned());
    if collected
        .accesses
        .iter()
        .any(|access| default_uses_any_removed_binding(access, &removed_bindings))
    {
        return None;
    }

    if ident_used_in_stmts(&stmts[i..], &ref_key) {
        return None;
    }
    for temp in &removed_temps {
        if ident_used_in_stmts(&stmts[i..], temp) {
            return None;
        }
    }

    let pat = build_pat_from_accesses(collected.accesses)?;
    let kind = declaration_kind_for_pattern_bindings(&pat, &stmts[start + 1..i], ref_decl.kind);
    let stmt = build_var_stmt(&ref_decl, pat, kind);
    Some(ReconstructedGroup {
        stmt,
        consumed: i - start,
        remove_prior_bindings: Vec::new(),
    })
}

struct CollectedAccesses {
    accesses: Vec<Access>,
    consumed: usize,
    consumed_helpers: Vec<BindingKey>,
}

fn collect_accesses_on(
    stmts: &[Stmt],
    start: usize,
    ref_ident: &Ident,
    unresolved_mark: Mark,
    removed_temps: &mut Vec<BindingKey>,
    consumed_helpers: &mut Vec<BindingKey>,
) -> CollectedAccesses {
    let mut accesses = Vec::new();
    let mut i = start;

    while i < stmts.len() {
        if let Some((access, consumed)) = try_extract_access(
            stmts,
            i,
            ref_ident,
            unresolved_mark,
            removed_temps,
            consumed_helpers,
        ) {
            accesses.push(access);
            i += consumed;
        } else {
            break;
        }
    }

    CollectedAccesses {
        accesses,
        consumed: i - start,
        consumed_helpers: Vec::new(),
    }
}

fn is_rest_or_default_access(access: &Access) -> bool {
    match access {
        Access::ArrayRest { .. } => true,
        Access::Array { pat, .. } | Access::Object { pat, .. } => matches!(pat, Pat::Assign(_)),
    }
}

#[derive(Clone, Copy, PartialEq, Eq)]
struct DeclGroup {
    span: Span,
    ctxt: SyntaxContext,
    kind: VarDeclKind,
    declare: bool,
}

fn same_decl_group_ignoring_kind(left: DeclGroup, right: DeclGroup) -> bool {
    left.span == right.span && left.ctxt == right.ctxt && left.declare == right.declare
}

fn try_reconstruct_direct_array_group(
    stmts: &[Stmt],
    start: usize,
    unresolved_mark: Mark,
) -> Option<ReconstructedGroup> {
    let (source, group, first_access, consumed, first_temp) =
        try_extract_direct_array_access(stmts, start, None, None, unresolved_mark)?;

    let mut accesses = vec![first_access];
    let mut removed_temps = Vec::new();
    if let Some(temp) = first_temp {
        removed_temps.push(temp);
    }

    let mut i = start + consumed;
    while i < stmts.len() {
        let next_default = try_extract_direct_default_access(
            stmts,
            i,
            Some(&source),
            Some(group),
            unresolved_mark,
        )
        .map(|(source, group, access, temp)| (source, group, access, 2, Some(temp)));

        let next_access = next_default.or_else(|| {
            try_extract_direct_array_access(stmts, i, Some(&source), Some(group), unresolved_mark)
        });

        if let Some((_, _, access, consumed, temp)) = next_access {
            accesses.push(access);
            if let Some(temp) = temp {
                removed_temps.push(temp);
            }
            i += consumed;
        } else {
            break;
        }
    }

    if !accesses
        .iter()
        .any(|access| matches!(access, Access::ArrayRest { .. }))
        || !accesses
            .iter()
            .any(|access| matches!(access, Access::Array { .. }))
    {
        return None;
    }

    if accesses
        .iter()
        .any(|access| default_uses_any_removed_binding(access, &removed_temps))
    {
        return None;
    }

    for temp in &removed_temps {
        if ident_used_in_stmts(&stmts[i..], temp) {
            return None;
        }
    }

    let pat = build_array_pat(accesses)?;
    let kind = declaration_kind_for_pattern_bindings(&pat, &stmts[start..i], group.kind);
    let stmt = build_var_stmt_from_parts(
        group.span,
        group.ctxt,
        kind,
        group.declare,
        pat,
        Box::new(Expr::Ident(source)),
    );
    Some(ReconstructedGroup {
        stmt,
        consumed: i - start,
        remove_prior_bindings: Vec::new(),
    })
}

fn try_extract_direct_array_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    expected_group: Option<DeclGroup>,
    unresolved_mark: Mark,
) -> Option<(Ident, DeclGroup, Access, usize, Option<BindingKey>)> {
    if let Some((source, group, access, temp)) = try_extract_direct_default_access(
        stmts,
        index,
        expected_source,
        expected_group,
        unresolved_mark,
    ) {
        return Some((source, group, access, 2, Some(temp)));
    }

    let (group, binding, init) = extract_grouped_binding_decl(stmts.get(index)?)?;
    if let Some(expected_group) = expected_group {
        if !same_decl_group_ignoring_kind(group, expected_group) {
            return None;
        }
    }

    if let Some((source, index)) = extract_direct_array_index(init, expected_source) {
        return Some((
            source,
            group,
            Access::Array {
                index,
                pat: Pat::Ident(binding),
            },
            1,
            None,
        ));
    }

    if let Some((source, start, binding)) =
        extract_direct_slice_rest(init, expected_source, binding)
    {
        return Some((source, group, Access::ArrayRest { start, binding }, 1, None));
    }

    None
}

fn try_extract_direct_default_access(
    stmts: &[Stmt],
    index: usize,
    expected_source: Option<&Ident>,
    expected_group: Option<DeclGroup>,
    unresolved_mark: Mark,
) -> Option<(Ident, DeclGroup, Access, BindingKey)> {
    let (group, temp, temp_init) = extract_grouped_binding_decl(stmts.get(index)?)?;
    if let Some(expected_group) = expected_group {
        if !same_decl_group_ignoring_kind(group, expected_group) {
            return None;
        }
    }
    let (source, array_index) = extract_direct_array_index(temp_init, expected_source)?;

    let (next_group, binding, binding_init) = extract_grouped_binding_decl(stmts.get(index + 1)?)?;
    if expected_group.is_some() && !same_decl_group_ignoring_kind(next_group, group) {
        return None;
    }
    let default = extract_default_value(binding_init, &temp.id, unresolved_mark)?;
    let temp_key = binding_key(&temp.id);
    if expr_uses_ident(&default, &temp_key) {
        return None;
    }

    let pat = Pat::Assign(AssignPat {
        span: DUMMY_SP,
        left: Box::new(Pat::Ident(binding)),
        right: default,
    });

    Some((
        source,
        group,
        Access::Array {
            index: array_index,
            pat,
        },
        temp_key,
    ))
}

fn extract_direct_array_index(
    expr: &Expr,
    expected_source: Option<&Ident>,
) -> Option<(Ident, usize)> {
    let Expr::Member(member) = expr else {
        return None;
    };
    let Expr::Ident(obj) = member.obj.as_ref() else {
        return None;
    };
    if let Some(expected) = expected_source {
        if obj.sym != expected.sym || obj.ctxt != expected.ctxt {
            return None;
        }
    }
    let MemberProp::Computed(computed) = &member.prop else {
        return None;
    };
    let Expr::Lit(Lit::Num(num)) = computed.expr.as_ref() else {
        return None;
    };
    Some((obj.clone(), numeric_index(num)?))
}

fn extract_direct_slice_rest(
    expr: &Expr,
    expected_source: Option<&Ident>,
    binding: BindingIdent,
) -> Option<(Ident, usize, BindingIdent)> {
    let Expr::Call(call) = expr else {
        return None;
    };
    if call.args.len() != 1 {
        return None;
    }
    let swc_core::ecma::ast::Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let Expr::Member(MemberExpr { obj, prop, .. }) = callee.as_ref() else {
        return None;
    };
    let Expr::Ident(source) = obj.as_ref() else {
        return None;
    };
    if let Some(expected) = expected_source {
        if source.sym != expected.sym || source.ctxt != expected.ctxt {
            return None;
        }
    }
    if !matches!(prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "slice") {
        return None;
    }
    let Expr::Lit(Lit::Num(num)) = call.args[0].expr.as_ref() else {
        return None;
    };
    Some((source.clone(), numeric_index(num)?, binding))
}

fn default_uses_any_removed_binding(access: &Access, removed_bindings: &[BindingKey]) -> bool {
    match access {
        Access::Array { pat, .. } | Access::Object { pat, .. } => {
            default_pat_uses_any_removed_binding(pat, removed_bindings)
        }
        Access::ArrayRest { .. } => false,
    }
}

fn default_pat_uses_any_removed_binding(pat: &Pat, removed_bindings: &[BindingKey]) -> bool {
    let Pat::Assign(assign) = pat else {
        return false;
    };
    removed_bindings
        .iter()
        .any(|binding| expr_uses_ident(&assign.right, binding))
}

fn extract_ref_decl(stmt: &Stmt) -> Option<RefDecl> {
    let Stmt::Decl(Decl::Var(var)) = stmt else {
        return None;
    };
    if var.decls.len() != 1 {
        return None;
    }
    let decl = &var.decls[0];
    let Pat::Ident(ident) = &decl.name else {
        return None;
    };
    let init = decl.init.as_ref()?;

    Some(RefDecl {
        span: var.span,
        ctxt: var.ctxt,
        kind: var.kind,
        declare: var.declare,
        ident: ident.clone(),
        init: unwrap_spread_array_source(init),
    })
}

fn unwrap_spread_array_source(expr: &Expr) -> Box<Expr> {
    if let Expr::Array(array) = expr {
        if array.elems.len() == 1 {
            if let Some(ExprOrSpread {
                spread: Some(_),
                expr,
            }) = &array.elems[0]
            {
                return expr.clone();
            }
        }
    }
    Box::new(expr.clone())
}

fn try_extract_access(
    stmts: &[Stmt],
    index: usize,
    ref_ident: &Ident,
    unresolved_mark: Mark,
    removed_temps: &mut Vec<BindingKey>,
    consumed_helpers: &mut Vec<BindingKey>,
) -> Option<(Access, usize)> {
    if let Some((mut access, temp)) =
        try_extract_default_access(stmts, index, ref_ident, unresolved_mark)
    {
        removed_temps.push(temp);
        let mut consumed = 2;

        if let Some((nested_pat, extra)) = try_nest_default_binding(
            &access,
            stmts,
            index + 2,
            unresolved_mark,
            removed_temps,
            consumed_helpers,
        ) {
            replace_access_left(&mut access, nested_pat);
            consumed += extra;
        }

        return Some((access, consumed));
    }

    let (binding, init) = extract_binding_decl(stmts.get(index)?)?;
    if let Some(source) = extract_source_access(init, ref_ident) {
        let access = match source {
            SourceAccess::ArrayIndex(index) => Access::Array {
                index,
                pat: Pat::Ident(binding),
            },
            SourceAccess::ObjectProp(key) => Access::Object {
                key,
                pat: Pat::Ident(binding),
            },
        };
        return Some((access, 1));
    }

    if let Some((start, binding, helper_key)) = extract_slice_rest(init, ref_ident, binding) {
        if let Some(key) = helper_key {
            consumed_helpers.push(key);
        }
        return Some((Access::ArrayRest { start, binding }, 1));
    }

    None
}

fn try_nest_default_binding(
    access: &Access,
    stmts: &[Stmt],
    nested_start: usize,
    unresolved_mark: Mark,
    removed_temps: &mut Vec<BindingKey>,
    consumed_helpers: &mut Vec<BindingKey>,
) -> Option<(Pat, usize)> {
    let default_binding = match access {
        Access::Object { pat, .. } | Access::Array { pat, .. } => {
            let Pat::Assign(assign) = pat else {
                return None;
            };
            let Pat::Ident(binding) = assign.left.as_ref() else {
                return None;
            };
            &binding.id
        }
        Access::ArrayRest { .. } => return None,
    };

    let collected = collect_accesses_on(
        stmts,
        nested_start,
        default_binding,
        unresolved_mark,
        removed_temps,
        consumed_helpers,
    );

    if collected.accesses.is_empty() || !collected.accesses.iter().any(is_rest_or_default_access) {
        return None;
    }

    let after_nested = nested_start + collected.consumed;
    let nested_key = binding_key(default_binding);
    if ident_used_in_stmts(&stmts[after_nested..], &nested_key) {
        return None;
    }

    removed_temps.push(nested_key);
    let nested_pat = build_pat_from_accesses(collected.accesses)?;
    Some((nested_pat, collected.consumed))
}

fn replace_access_left(access: &mut Access, nested_pat: Pat) {
    let pat = match access {
        Access::Object { pat, .. } | Access::Array { pat, .. } => pat,
        Access::ArrayRest { .. } => return,
    };
    let Pat::Assign(assign) = pat else { return };
    *assign.left = nested_pat;
}

fn try_extract_default_access(
    stmts: &[Stmt],
    index: usize,
    ref_ident: &Ident,
    unresolved_mark: Mark,
) -> Option<(Access, BindingKey)> {
    let (temp, temp_init) = extract_binding_decl(stmts.get(index)?)?;
    let source = extract_source_access(temp_init, ref_ident)?;

    let (binding, binding_init) = extract_binding_decl(stmts.get(index + 1)?)?;
    let default = extract_default_value(binding_init, &temp.id, unresolved_mark)?;
    let temp_key = binding_key(&temp.id);
    if expr_uses_ident(&default, &temp_key) {
        return None;
    }

    let pat = Pat::Assign(AssignPat {
        span: DUMMY_SP,
        left: Box::new(Pat::Ident(binding)),
        right: default,
    });

    let access = match source {
        SourceAccess::ArrayIndex(index) => Access::Array { index, pat },
        SourceAccess::ObjectProp(key) => Access::Object { key, pat },
    };

    Some((access, temp_key))
}

fn extract_binding_decl(stmt: &Stmt) -> Option<(BindingIdent, &Expr)> {
    let Stmt::Decl(Decl::Var(var)) = stmt else {
        return None;
    };
    if var.decls.len() != 1 {
        return None;
    }
    let decl = &var.decls[0];
    let Pat::Ident(binding) = &decl.name else {
        return None;
    };
    Some((binding.clone(), decl.init.as_deref()?))
}

fn extract_binding_assignment(stmt: &Stmt) -> Option<(BindingIdent, &Expr)> {
    let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
        return None;
    };
    let Expr::Assign(assign) = strip_parens(expr.as_ref()) else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Ident(binding)) = &assign.left else {
        return None;
    };
    Some((binding.clone(), strip_parens(assign.right.as_ref())))
}

fn extract_grouped_binding_decl(stmt: &Stmt) -> Option<(DeclGroup, BindingIdent, &Expr)> {
    let Stmt::Decl(Decl::Var(var)) = stmt else {
        return None;
    };
    if var.decls.len() != 1 {
        return None;
    }
    let decl = &var.decls[0];
    let Pat::Ident(binding) = &decl.name else {
        return None;
    };
    Some((
        DeclGroup {
            span: var.span,
            ctxt: var.ctxt,
            kind: var.kind,
            declare: var.declare,
        },
        binding.clone(),
        decl.init.as_deref()?,
    ))
}

fn extract_assignment_source_access(
    expr: &Expr,
    expected_source: Option<&Ident>,
) -> Option<(Ident, Box<Expr>, SourceAccess)> {
    let Expr::Member(member) = strip_parens(expr) else {
        return None;
    };
    let (source, source_init) =
        extract_assignment_source_expr(member.obj.as_ref(), expected_source)?;

    let access = match &member.prop {
        MemberProp::Ident(prop) => SourceAccess::ObjectProp(PropKey::Ident(prop.sym.clone())),
        MemberProp::Computed(computed) => match strip_parens(computed.expr.as_ref()) {
            Expr::Lit(Lit::Num(num)) => SourceAccess::ArrayIndex(numeric_index(num)?),
            Expr::Lit(Lit::Str(s)) => {
                SourceAccess::ObjectProp(PropKey::Str(s.value.as_str().map(Atom::from)?))
            }
            _ => return None,
        },
        _ => return None,
    };

    Some((source, source_init, access))
}

fn extract_default_member_access(
    expr: &Expr,
    temp: &Ident,
    unresolved_mark: Mark,
) -> Option<(Box<Expr>, SourceAccess)> {
    let Expr::Member(member) = strip_parens(expr) else {
        return None;
    };
    let default = extract_default_value(strip_parens(member.obj.as_ref()), temp, unresolved_mark)?;
    let access = source_access_from_member_prop(&member.prop)?;
    Some((default, access))
}

fn source_access_from_member_prop(prop: &MemberProp) -> Option<SourceAccess> {
    match prop {
        MemberProp::Ident(prop) => Some(SourceAccess::ObjectProp(PropKey::Ident(prop.sym.clone()))),
        MemberProp::Computed(computed) => match strip_parens(computed.expr.as_ref()) {
            Expr::Lit(Lit::Num(num)) => numeric_index(num).map(SourceAccess::ArrayIndex),
            Expr::Lit(Lit::Str(s)) => s
                .value
                .as_str()
                .map(|value| SourceAccess::ObjectProp(PropKey::Str(value.into()))),
            _ => None,
        },
        _ => None,
    }
}

fn sliced_to_array_callee_binding(
    expr: &Expr,
    sliced_to_array_helpers: &HashSet<BindingKey>,
) -> Option<BindingKey> {
    let Expr::Ident(callee) = strip_parens(expr) else {
        return None;
    };
    let key = binding_key(callee);
    sliced_to_array_helpers.contains(&key).then_some(key)
}

fn extract_assignment_source_expr(
    expr: &Expr,
    expected_source: Option<&Ident>,
) -> Option<(Ident, Box<Expr>)> {
    match strip_parens(expr) {
        Expr::Ident(source) => {
            if let Some(expected) = expected_source {
                if source.sym != expected.sym || source.ctxt != expected.ctxt {
                    return None;
                }
            }
            Some((source.clone(), Box::new(Expr::Ident(source.clone()))))
        }
        Expr::Assign(assign) if expected_source.is_none() && assign.op == AssignOp::Assign => {
            let AssignTarget::Simple(SimpleAssignTarget::Ident(source)) = &assign.left else {
                return None;
            };
            Some((source.id.clone(), Box::new(Expr::Assign(assign.clone()))))
        }
        _ => None,
    }
}

fn extract_source_access(expr: &Expr, ref_ident: &Ident) -> Option<SourceAccess> {
    let Expr::Member(member) = expr else {
        return None;
    };
    let Expr::Ident(obj) = member.obj.as_ref() else {
        return None;
    };
    if obj.sym != ref_ident.sym || obj.ctxt != ref_ident.ctxt {
        return None;
    }

    match &member.prop {
        MemberProp::Ident(prop) => Some(SourceAccess::ObjectProp(PropKey::Ident(prop.sym.clone()))),
        MemberProp::Computed(computed) => match computed.expr.as_ref() {
            Expr::Lit(Lit::Num(num)) => numeric_index(num).map(SourceAccess::ArrayIndex),
            Expr::Lit(Lit::Str(s)) => s
                .value
                .as_str()
                .map(|value| SourceAccess::ObjectProp(PropKey::Str(value.into()))),
            _ => None,
        },
        _ => None,
    }
}

fn extract_slice_rest(
    expr: &Expr,
    ref_ident: &Ident,
    binding: BindingIdent,
) -> Option<(usize, BindingIdent, Option<BindingKey>)> {
    let Expr::Call(call) = expr else {
        return None;
    };
    if call.args.len() != 1 {
        return None;
    }
    let swc_core::ecma::ast::Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let Expr::Member(MemberExpr { obj, prop, .. }) = callee.as_ref() else {
        return None;
    };
    let helper_key = match_ref_or_array_like_to_array(obj, ref_ident)?;
    if !matches!(prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "slice") {
        return None;
    }
    let Expr::Lit(Lit::Num(num)) = call.args[0].expr.as_ref() else {
        return None;
    };
    Some((numeric_index(num)?, binding, helper_key))
}

/// Checks whether `expr` is `ref_ident` or `_arrayLikeToArray(ref_ident)`.
/// Returns `Some(helper_binding_key)` when the `_arrayLikeToArray` wrapper was
/// matched, `Some(None)` for a direct ref match, or `None` on mismatch.
fn match_ref_or_array_like_to_array(expr: &Expr, ref_ident: &Ident) -> Option<Option<BindingKey>> {
    match expr {
        Expr::Ident(obj) if obj.sym == ref_ident.sym && obj.ctxt == ref_ident.ctxt => Some(None),
        Expr::Call(call) => {
            if call.args.is_empty() || call.args[0].spread.is_some() {
                return None;
            }
            let swc_core::ecma::ast::Callee::Expr(callee) = &call.callee else {
                return None;
            };
            let Expr::Ident(helper) = callee.as_ref() else {
                return None;
            };
            if !matches!(
                helper.sym.as_ref(),
                "_arrayLikeToArray" | "_array_like_to_array"
            ) {
                return None;
            }
            match_ref_or_array_like_to_array(call.args[0].expr.as_ref(), ref_ident)?;
            Some(Some(binding_key(helper)))
        }
        _ => None,
    }
}

fn numeric_index(num: &Number) -> Option<usize> {
    if num.value < 0.0 || num.value.fract() != 0.0 || num.value > 64.0 {
        return None;
    }
    Some(num.value as usize)
}

/// Extract the default value from the first argument of `_slicedToArray()`.
fn extract_sliced_default_arg(
    expr: &Expr,
    temp: &Ident,
    unresolved_mark: Mark,
) -> Option<(Box<Expr>, Option<Ident>)> {
    if let Some(default) = extract_default_value(expr, temp, unresolved_mark) {
        return Some((default, None));
    }
    let Expr::Assign(assign) = strip_parens(expr) else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Ident(fused_binding)) = &assign.left else {
        return None;
    };
    let default =
        extract_default_value(strip_parens(assign.right.as_ref()), temp, unresolved_mark)?;
    Some((default, Some(fused_binding.id.clone())))
}

fn extract_default_value(expr: &Expr, temp: &Ident, unresolved_mark: Mark) -> Option<Box<Expr>> {
    extract_ternary_default(expr, temp, unresolved_mark)
        .or_else(|| extract_boolean_default(expr, temp, unresolved_mark))
}

fn extract_ternary_default(expr: &Expr, temp: &Ident, unresolved_mark: Mark) -> Option<Box<Expr>> {
    let Expr::Cond(cond) = expr else {
        return None;
    };
    if !is_undefined_test(&cond.test, temp, unresolved_mark) || !is_ident_expr(&cond.alt, temp) {
        return None;
    }
    Some(cond.cons.clone())
}

fn extract_boolean_default(expr: &Expr, temp: &Ident, unresolved_mark: Mark) -> Option<Box<Expr>> {
    let Expr::Bin(bin) = expr else {
        return None;
    };

    match bin.op {
        BinaryOp::LogicalAnd
            if is_defined_test(&bin.left, temp, unresolved_mark)
                && is_ident_expr(&bin.right, temp) =>
        {
            Some(bool_expr(false))
        }
        BinaryOp::LogicalOr
            if is_undefined_test(&bin.left, temp, unresolved_mark)
                && is_ident_expr(&bin.right, temp) =>
        {
            Some(bool_expr(true))
        }
        _ => None,
    }
}

fn bool_expr(value: bool) -> Box<Expr> {
    Box::new(Expr::Lit(Lit::Bool(Bool {
        span: DUMMY_SP,
        value,
    })))
}

fn is_undefined_test(expr: &Expr, temp: &Ident, unresolved_mark: Mark) -> bool {
    let Expr::Bin(bin) = expr else {
        return false;
    };
    bin.op == BinaryOp::EqEqEq
        && ((is_ident_expr(&bin.left, temp)
            && is_unresolved_undefined(&bin.right, unresolved_mark))
            || (is_unresolved_undefined(&bin.left, unresolved_mark)
                && is_ident_expr(&bin.right, temp)))
}

fn is_defined_test(expr: &Expr, temp: &Ident, unresolved_mark: Mark) -> bool {
    let Expr::Bin(bin) = expr else {
        return false;
    };
    bin.op == BinaryOp::NotEqEq
        && ((is_ident_expr(&bin.left, temp)
            && is_unresolved_undefined(&bin.right, unresolved_mark))
            || (is_unresolved_undefined(&bin.left, unresolved_mark)
                && is_ident_expr(&bin.right, temp)))
}

fn is_ident_expr(expr: &Expr, ident: &Ident) -> bool {
    matches!(expr, Expr::Ident(id) if id.sym == ident.sym && id.ctxt == ident.ctxt)
}

fn build_pat_from_accesses(accesses: Vec<Access>) -> Option<Pat> {
    if accesses
        .iter()
        .all(|access| matches!(access, Access::Array { .. } | Access::ArrayRest { .. }))
    {
        build_array_pat(accesses)
    } else if accesses
        .iter()
        .all(|access| matches!(access, Access::Object { .. }))
    {
        build_object_pat(accesses)
    } else {
        None
    }
}

fn build_assignment_destructuring_stmt(
    span: Span,
    accesses: Vec<Access>,
    init: Box<Expr>,
) -> Option<Stmt> {
    let pat = build_pat_from_accesses(accesses)?;
    let left = match pat {
        Pat::Array(array) => AssignTarget::Pat(AssignTargetPat::Array(array)),
        Pat::Object(object) => AssignTarget::Pat(AssignTargetPat::Object(object)),
        _ => return None,
    };

    Some(Stmt::Expr(ExprStmt {
        span,
        expr: Box::new(Expr::Assign(AssignExpr {
            span,
            op: AssignOp::Assign,
            left,
            right: init,
        })),
    }))
}

fn build_array_pat(accesses: Vec<Access>) -> Option<Pat> {
    if accesses
        .iter()
        .filter(|access| matches!(access, Access::ArrayRest { .. }))
        .count()
        > 1
    {
        return None;
    }

    let rest = accesses.iter().find_map(|access| {
        if let Access::ArrayRest { start, binding } = access {
            Some((*start, binding.clone()))
        } else {
            None
        }
    });

    let max_index = accesses
        .iter()
        .filter_map(|access| match access {
            Access::Array { index, .. } => Some(*index),
            _ => None,
        })
        .max()
        .unwrap_or(0);

    if let Some((rest_start, _)) = &rest {
        if accesses
            .iter()
            .any(|access| matches!(access, Access::Array { index, .. } if index >= rest_start))
        {
            return None;
        }
    }

    let elem_len = rest
        .as_ref()
        .map(|(start, _)| start + 1)
        .unwrap_or(max_index + 1);
    let mut elems: Vec<Option<Pat>> = vec![None; elem_len];

    for access in accesses {
        match access {
            Access::Array { index, pat } => {
                if elems[index].is_some() {
                    return None;
                }
                elems[index] = Some(pat);
            }
            Access::ArrayRest { start, binding } => {
                if elems[start].is_some() {
                    return None;
                }
                elems[start] = Some(Pat::Rest(RestPat {
                    span: DUMMY_SP,
                    dot3_token: DUMMY_SP,
                    arg: Box::new(Pat::Ident(binding)),
                    type_ann: None,
                }));
            }
            Access::Object { .. } => return None,
        }
    }

    Some(Pat::Array(ArrayPat {
        span: DUMMY_SP,
        elems,
        optional: false,
        type_ann: None,
    }))
}

fn build_object_pat(accesses: Vec<Access>) -> Option<Pat> {
    let mut props = Vec::with_capacity(accesses.len());

    for access in accesses {
        let Access::Object { key, pat } = access else {
            return None;
        };
        props.push(build_object_prop(key, pat));
    }

    Some(Pat::Object(ObjectPat {
        span: DUMMY_SP,
        props,
        optional: false,
        type_ann: None,
    }))
}

fn build_object_prop(key: PropKey, pat: Pat) -> ObjectPatProp {
    let prop_sym = match &key {
        PropKey::Ident(sym) | PropKey::Str(sym) => sym.clone(),
    };

    if let Pat::Ident(binding) = &pat {
        if binding.id.sym == prop_sym && matches!(key, PropKey::Ident(_)) {
            return ObjectPatProp::Assign(AssignPatProp {
                span: DUMMY_SP,
                key: binding.clone(),
                value: None,
            });
        }
    }

    if let Pat::Assign(assign) = &pat {
        if let Pat::Ident(binding) = assign.left.as_ref() {
            if binding.id.sym == prop_sym && matches!(key, PropKey::Ident(_)) {
                return ObjectPatProp::Assign(AssignPatProp {
                    span: DUMMY_SP,
                    key: binding.clone(),
                    value: Some(assign.right.clone()),
                });
            }
        }
    }

    ObjectPatProp::KeyValue(KeyValuePatProp {
        key: prop_name(key),
        value: Box::new(pat),
    })
}

fn prop_name(key: PropKey) -> PropName {
    match key {
        PropKey::Ident(sym) => PropName::Ident(IdentName::new(sym, DUMMY_SP)),
        PropKey::Str(sym) => PropName::Str(swc_core::ecma::ast::Str {
            span: DUMMY_SP,
            value: sym.as_str().into(),
            raw: None,
        }),
    }
}

fn declaration_kind_for_pattern_bindings(
    pat: &Pat,
    stmts: &[Stmt],
    fallback: VarDeclKind,
) -> VarDeclKind {
    let mut bindings = HashSet::new();
    collect_pat_binding_keys(pat, &mut bindings);
    if bindings.is_empty() {
        return fallback;
    }

    let mut kind = None;
    for stmt in stmts {
        let Stmt::Decl(Decl::Var(var)) = stmt else {
            continue;
        };
        for decl in &var.decls {
            if pat_binds_any_key(&decl.name, &bindings) {
                kind = Some(match kind {
                    Some(current) => widest_var_decl_kind(current, var.kind),
                    None => var.kind,
                });
            }
        }
    }

    kind.unwrap_or(fallback)
}

fn widest_var_decl_kind(left: VarDeclKind, right: VarDeclKind) -> VarDeclKind {
    match (left, right) {
        (VarDeclKind::Var, _) | (_, VarDeclKind::Var) => VarDeclKind::Var,
        (VarDeclKind::Let, _) | (_, VarDeclKind::Let) => VarDeclKind::Let,
        _ => left,
    }
}

fn pat_binds_any_key(pat: &Pat, targets: &HashSet<BindingKey>) -> bool {
    let mut bindings = HashSet::new();
    collect_pat_binding_keys(pat, &mut bindings);
    bindings.iter().any(|key| targets.contains(key))
}

fn collect_pat_binding_keys(pat: &Pat, bindings: &mut HashSet<BindingKey>) {
    match pat {
        Pat::Ident(binding) => {
            bindings.insert(binding_key(&binding.id));
        }
        Pat::Array(array) => {
            for elem in array.elems.iter().flatten() {
                collect_pat_binding_keys(elem, bindings);
            }
        }
        Pat::Object(object) => {
            for prop in &object.props {
                match prop {
                    ObjectPatProp::KeyValue(kv) => {
                        collect_pat_binding_keys(&kv.value, bindings);
                    }
                    ObjectPatProp::Assign(assign) => {
                        bindings.insert(binding_key(&assign.key));
                    }
                    ObjectPatProp::Rest(rest) => {
                        collect_pat_binding_keys(&rest.arg, bindings);
                    }
                }
            }
        }
        Pat::Rest(rest) => collect_pat_binding_keys(&rest.arg, bindings),
        Pat::Assign(assign) => collect_pat_binding_keys(&assign.left, bindings),
        _ => {}
    }
}

fn build_var_stmt(ref_decl: &RefDecl, pat: Pat, kind: VarDeclKind) -> Stmt {
    build_var_stmt_from_parts(
        ref_decl.span,
        ref_decl.ctxt,
        kind,
        ref_decl.declare,
        pat,
        ref_decl.init.clone(),
    )
}

fn build_var_stmt_from_parts(
    span: swc_core::common::Span,
    ctxt: swc_core::common::SyntaxContext,
    kind: VarDeclKind,
    declare: bool,
    pat: Pat,
    init: Box<Expr>,
) -> Stmt {
    Stmt::Decl(Decl::Var(Box::new(VarDecl {
        span,
        ctxt,
        kind,
        declare,
        decls: vec![VarDeclarator {
            span: DUMMY_SP,
            name: pat,
            init: Some(init),
            definite: false,
        }],
    })))
}

fn nest_param_destructuring(params: &mut [Param], body: &mut BlockStmt, unresolved_mark: Mark) {
    for param in params.iter_mut() {
        nest_pat_destructuring(&mut param.pat, &mut body.stmts, unresolved_mark);
    }
}

fn nest_pat_destructuring(pat: &mut Pat, stmts: &mut Vec<Stmt>, unresolved_mark: Mark) {
    let inner_pat = match pat {
        Pat::Assign(assign) => &mut *assign.left,
        other => other,
    };
    let props = match inner_pat {
        Pat::Object(obj) => &mut obj.props,
        _ => return,
    };

    for prop in props.iter_mut() {
        let value_pat = match prop {
            ObjectPatProp::KeyValue(kv) => &mut *kv.value,
            _ => continue,
        };
        let Pat::Assign(assign) = value_pat else {
            continue;
        };
        let Pat::Ident(binding) = assign.left.as_ref() else {
            continue;
        };

        let mut removed_temps = Vec::new();
        let mut consumed_helpers = Vec::new();
        let collected = collect_accesses_on(
            stmts,
            0,
            &binding.id,
            unresolved_mark,
            &mut removed_temps,
            &mut consumed_helpers,
        );

        if collected.accesses.is_empty()
            || !collected.accesses.iter().any(is_rest_or_default_access)
        {
            continue;
        }

        let nested_key = binding_key(&binding.id);
        if ident_used_in_stmts(&stmts[collected.consumed..], &nested_key) {
            continue;
        }
        for temp in &removed_temps {
            if ident_used_in_stmts(&stmts[collected.consumed..], temp) {
                continue;
            }
        }

        let Some(nested_pat) = build_pat_from_accesses(collected.accesses) else {
            continue;
        };

        *assign.left = nested_pat;
        stmts.drain(0..collected.consumed);
        return;
    }
}

/// Remove function/var declarations for helper bindings that are no longer
/// referenced after destructuring reconstruction consumed their call sites.
fn remove_unreferenced_helpers(stmts: &mut Vec<Stmt>, helpers: &[BindingKey]) {
    use std::collections::HashSet;
    let helper_set: HashSet<&BindingKey> = helpers.iter().collect();

    // Collect which helpers are still referenced outside their own declaration.
    let mut referenced: HashSet<&BindingKey> = HashSet::new();
    for stmt in stmts.iter() {
        let declaring = stmt_declares_binding(stmt);
        for key in &helper_set {
            if declaring.as_ref() == Some(*key) {
                continue;
            }
            if stmt_uses_binding(stmt, key) {
                referenced.insert(*key);
            }
        }
    }

    let dead: HashSet<&BindingKey> = helper_set.difference(&referenced).copied().collect();
    if dead.is_empty() {
        return;
    }
    stmts.retain(|stmt| {
        if let Some(key) = stmt_declares_binding(stmt) {
            !dead.contains(&key)
        } else {
            true
        }
    });
}

fn stmt_declares_binding(stmt: &Stmt) -> Option<BindingKey> {
    match stmt {
        Stmt::Decl(Decl::Fn(fn_decl)) => Some(binding_key(&fn_decl.ident)),
        Stmt::Decl(Decl::Var(var_decl)) if var_decl.decls.len() == 1 => {
            let Pat::Ident(ident) = &var_decl.decls[0].name else {
                return None;
            };
            Some(binding_key(&ident.id))
        }
        _ => None,
    }
}

fn stmt_uses_binding(stmt: &Stmt, key: &BindingKey) -> bool {
    let mut finder = IdentUseFinder {
        key: (*key).clone(),
        found: false,
    };
    stmt.visit_with(&mut finder);
    finder.found
}

fn ident_used_in_stmts(stmts: &[Stmt], key: &BindingKey) -> bool {
    let mut finder = IdentUseFinder {
        key: key.clone(),
        found: false,
    };
    for stmt in stmts {
        stmt.visit_with(&mut finder);
        if finder.found {
            return true;
        }
    }
    false
}

fn expr_uses_ident(expr: &Expr, key: &BindingKey) -> bool {
    let mut finder = IdentUseFinder {
        key: key.clone(),
        found: false,
    };
    expr.visit_with(&mut finder);
    finder.found
}

struct IdentUseFinder {
    key: BindingKey,
    found: bool,
}

impl Visit for IdentUseFinder {
    fn visit_ident(&mut self, ident: &Ident) {
        if binding_key(ident) == self.key {
            self.found = true;
        }
    }

    fn visit_member_prop(&mut self, prop: &MemberProp) {
        if let MemberProp::Computed(computed) = prop {
            computed.visit_with(self);
        }
    }

    fn visit_prop_name(&mut self, _: &PropName) {}
}