crates/core/src/rules/un_argument_spread.rs

GitHub
use swc_core::common::{Mark, DUMMY_SP};
use swc_core::ecma::ast::{
    AssignOp, AssignTarget, CallExpr, Callee, Expr, ExprOrSpread, ExprStmt, Ident, Lit, MemberExpr,
    MemberProp, SimpleAssignTarget, Stmt,
};
use swc_core::ecma::visit::{VisitMut, VisitMutWith};

use super::decl_utils::{
    can_remove_prior_uninitialized_decls, ident_is_used_in_stmts_excluding_bindings,
    remove_prior_uninitialized_decls, same_ident, UninitializedDeclKind,
};
use super::expr_utils::{exprs_structurally_equal, is_unresolved_undefined};
use super::RewriteLevel;

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

pub struct UnArgumentSpread {
    unresolved_mark: Mark,
    level: RewriteLevel,
}

impl UnArgumentSpread {
    pub fn new(unresolved_mark: Mark, level: RewriteLevel) -> Self {
        Self {
            unresolved_mark,
            level,
        }
    }
}

impl Default for UnArgumentSpread {
    fn default() -> Self {
        Self::new(Mark::new(), RewriteLevel::Standard)
    }
}

impl VisitMut for UnArgumentSpread {
    fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
        stmts.visit_mut_children_with(self);

        if self.level < RewriteLevel::Standard {
            return;
        }

        let old = std::mem::take(stmts);
        let mut index = 0;
        while index < old.len() {
            if index + 1 < old.len() {
                if let Some(rewrite) = try_convert_split_memoized_apply(
                    &old[index],
                    &old[index + 1],
                    &old[index + 2..],
                ) {
                    if can_remove_prior_uninitialized_decls(
                        stmts,
                        &rewrite.removable_bindings,
                        UninitializedDeclKind::Any,
                    ) {
                        let end = stmts.len();
                        remove_prior_uninitialized_decls(
                            stmts,
                            end,
                            &rewrite.removable_bindings,
                            UninitializedDeclKind::Any,
                        );
                        stmts.push(rewrite.stmt);
                        index += 2;
                        continue;
                    }
                }
            }

            stmts.push(old[index].clone());
            index += 1;
        }
    }

    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        if self.level < RewriteLevel::Standard {
            return;
        }

        let taken = match expr {
            Expr::Call(_) => {
                let placeholder = Expr::Lit(Lit::Num(swc_core::ecma::ast::Number {
                    span: DUMMY_SP,
                    value: 0.0,
                    raw: None,
                }));
                std::mem::replace(expr, placeholder)
            }
            _ => return,
        };

        let Expr::Call(call) = taken else {
            *expr = taken;
            return;
        };

        match try_convert_apply(call, self.unresolved_mark) {
            Ok(new_expr) => *expr = new_expr,
            Err(original_call) => *expr = Expr::Call(original_call),
        }
    }
}

fn try_convert_apply(call: CallExpr, unresolved_mark: Mark) -> Result<Expr, CallExpr> {
    // callee must be a member expression ending in `.apply`
    let callee_member = match &call.callee {
        Callee::Expr(e) => match e.as_ref() {
            Expr::Member(m) => m,
            _ => return Err(call),
        },
        _ => return Err(call),
    };

    // Check that the property is `apply`
    match &callee_member.prop {
        MemberProp::Ident(ident_name) if ident_name.sym.as_ref() == "apply" => {}
        _ => return Err(call),
    }

    // We need exactly 2 arguments
    if call.args.len() != 2 {
        return Err(call);
    }

    // Check for spread on either arg – we don't handle those
    if call.args[0].spread.is_some() || call.args[1].spread.is_some() {
        return Err(call);
    }

    let first_arg = call.args[0].expr.as_ref();
    let callee_obj = callee_member.obj.as_ref();

    // Pattern 1: fn.apply(null/undefined, arg2) → fn(...arg2)
    // Only applies when the callee object is NOT itself a member expression
    // (i.e., the callee is just `fn`, not `obj.fn`)
    // Actually per the JS spec, for plain fn.apply(null/undefined) we convert regardless.
    // But if it's obj.fn.apply(obj, ...) we match pattern 2 instead.
    // Determine which pattern applies:

    // Pattern 2: obj.fn.apply(obj, arg2) → obj.fn(...arg2)
    // The callee's object is a member expression AND first arg equals the outer object.
    // e.g. callee = obj.fn.apply, callee_obj = obj.fn (Member), first_arg should = obj
    if let Expr::Member(callee_member_obj) = callee_obj {
        if exprs_structurally_equal(first_arg, &callee_member_obj.obj) {
            return Ok(make_spread_call(call));
        }
        if let Some(receiver) = memoized_receiver_source(&callee_member_obj.obj, first_arg) {
            return Ok(make_spread_call_with_member_receiver(call, receiver));
        }
        // obj.fn.apply(null/undefined, ...) — Babel spread artifact for standalone
        // function calls on module namespaces (e.g. `r.applyMiddleware.apply(void 0, d)`).
        // Not converted here because it changes `this` from undefined to obj.
        // The proper fix is namespace import decomposition (r.fn → fn), after which
        // Pattern 1 (simple ident) handles it.
        return Err(call);
    }

    // Pattern 1: callee obj is not a member expression, first arg must be null/undefined
    if matches!(first_arg, Expr::Lit(Lit::Null(_)))
        || is_unresolved_undefined(first_arg, unresolved_mark)
    {
        return Ok(make_spread_call(call));
    }

    Err(call)
}

fn try_convert_split_memoized_apply(
    method_stmt: &Stmt,
    apply_stmt: &Stmt,
    rest: &[Stmt],
) -> Option<SplitMemoizedApplyRewrite> {
    let (method_temp, memoized_member) = memoized_method_assignment(method_stmt)?;
    let apply_call = expr_stmt_call(apply_stmt)?;

    if apply_call.args.len() != 2
        || apply_call.args[0].spread.is_some()
        || apply_call.args[1].spread.is_some()
    {
        return None;
    }

    let apply_member = match &apply_call.callee {
        Callee::Expr(callee) => match callee.as_ref() {
            Expr::Member(member) => member,
            _ => return None,
        },
        _ => return None,
    };
    if !matches!(&apply_member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "apply") {
        return None;
    }
    if !matches!(apply_member.obj.as_ref(), Expr::Ident(id) if same_ident(id, &method_temp)) {
        return None;
    }

    let first_arg = apply_call.args[0].expr.as_ref();
    let mut removable_bindings = vec![method_temp.clone()];
    let receiver = if exprs_structurally_equal(first_arg, &memoized_member.obj) {
        memoized_member.obj.clone()
    } else {
        let receiver_temp = ident_expr(first_arg)?;
        removable_bindings.push(receiver_temp.clone());
        memoized_receiver_source(&memoized_member.obj, first_arg)?
    };

    if removable_bindings
        .iter()
        .any(|binding| ident_is_used_in_stmts_excluding_bindings(binding, rest))
    {
        return None;
    }

    let mut args = args_from_apply_arg(apply_call.args[1].expr.clone());
    let callee = Expr::Member(MemberExpr {
        span: memoized_member.span,
        obj: receiver,
        prop: memoized_member.prop.clone(),
    });

    Some(SplitMemoizedApplyRewrite {
        stmt: Stmt::Expr(ExprStmt {
            span: apply_call.span,
            expr: Box::new(Expr::Call(CallExpr {
                span: apply_call.span,
                ctxt: apply_call.ctxt,
                callee: Callee::Expr(Box::new(callee)),
                args: std::mem::take(&mut args),
                type_args: apply_call.type_args.clone(),
            })),
        }),
        removable_bindings,
    })
}

struct SplitMemoizedApplyRewrite {
    stmt: Stmt,
    removable_bindings: Vec<Ident>,
}

fn memoized_method_assignment(stmt: &Stmt) -> Option<(Ident, &MemberExpr)> {
    let Stmt::Expr(expr_stmt) = stmt else {
        return None;
    };
    let Expr::Assign(assign) = expr_stmt.expr.as_ref() else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Ident(method_temp)) = &assign.left else {
        return None;
    };
    let Expr::Member(member) = assign.right.as_ref() else {
        return None;
    };
    Some((method_temp.id.clone(), member))
}

fn expr_stmt_call(stmt: &Stmt) -> Option<&CallExpr> {
    let Stmt::Expr(expr_stmt) = stmt else {
        return None;
    };
    let Expr::Call(call) = expr_stmt.expr.as_ref() else {
        return None;
    };
    Some(call)
}

fn ident_expr(expr: &Expr) -> Option<&Ident> {
    match expr {
        Expr::Ident(ident) => Some(ident),
        _ => None,
    }
}

fn args_from_apply_arg(arg: Box<Expr>) -> Vec<ExprOrSpread> {
    match *arg {
        Expr::Array(array) if array.elems.iter().all(Option::is_some) => {
            array.elems.into_iter().flatten().collect()
        }
        expr => vec![ExprOrSpread {
            spread: Some(DUMMY_SP),
            expr: Box::new(expr),
        }],
    }
}

/// Build `fn(...secondArg)` from the original `.apply(thisArg, secondArg)` call.
fn make_spread_call(call: CallExpr) -> Expr {
    // Consume the call
    let CallExpr {
        span,
        ctxt,
        callee,
        mut args,
        type_args,
    } = call;

    // callee is `fn.apply` – we want just `fn`
    let Callee::Expr(callee_box) = callee else {
        unreachable!()
    };
    let Expr::Member(member) = *callee_box else {
        unreachable!()
    };
    let fn_expr = member.obj;

    // second arg becomes the spread argument
    let second_arg = args.remove(1).expr;

    Expr::Call(CallExpr {
        span,
        ctxt,
        callee: Callee::Expr(fn_expr),
        args: vec![ExprOrSpread {
            spread: Some(DUMMY_SP),
            expr: second_arg,
        }],
        type_args,
    })
}

fn memoized_receiver_source(receiver_expr: &Expr, first_arg: &Expr) -> Option<Box<Expr>> {
    let receiver_expr = strip_parens(receiver_expr);
    let Expr::Assign(assign) = receiver_expr else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }
    let AssignTarget::Simple(SimpleAssignTarget::Ident(target)) = &assign.left else {
        return None;
    };
    if !matches!(first_arg, Expr::Ident(id) if id.sym == target.id.sym && id.ctxt == target.id.ctxt)
    {
        return None;
    }
    Some(assign.right.clone())
}

fn make_spread_call_with_member_receiver(mut call: CallExpr, receiver: Box<Expr>) -> Expr {
    if let Callee::Expr(callee) = &mut call.callee {
        if let Expr::Member(apply_member) = callee.as_mut() {
            if let Expr::Member(fn_member) = apply_member.obj.as_mut() {
                fn_member.obj = receiver;
            }
        }
    }
    make_spread_call(call)
}