crates/core/src/rules/arrow_function.rs

GitHub
use std::collections::HashSet;
use swc_core::atoms::Atom;
use swc_core::common::{SyntaxContext, DUMMY_SP};

use swc_core::ecma::ast::{
    ArrowExpr, AssignExpr, AssignTarget, BlockStmt, BlockStmtOrExpr, CallExpr, Callee, Expr,
    FnExpr, Function, Ident, KeyValueProp, MemberProp, Module, Pat, SimpleAssignTarget, ThisExpr,
    VarDeclarator,
};
use swc_core::ecma::visit::{Visit, VisitMut, VisitMutWith, VisitWith};

use crate::analysis::binding_uses::{BindingId, BindingUseIndex};

use super::decl_utils::has_duplicate_param_names;
use super::eval_utils::{direct_eval_call_source, js_source_mentions_binding, EvalCallSource};

pub struct ArrowFunction;

impl VisitMut for ArrowFunction {
    fn visit_mut_module(&mut self, module: &mut Module) {
        let constructed_bindings = collect_constructed_bindings(module);
        module.visit_mut_with(&mut ArrowFunctionConverter {
            constructed_bindings: &constructed_bindings,
        });
    }
}

struct ArrowFunctionConverter<'a> {
    constructed_bindings: &'a HashSet<BindingId>,
}

impl VisitMut for ArrowFunctionConverter<'_> {
    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        if let Expr::Fn(fn_expr) = expr {
            if let Some(arrow) = try_convert_to_arrow(fn_expr) {
                *expr = Expr::Arrow(arrow);
            }
            return;
        }

        // Handle `function(...) { ... }.bind(this)` → arrow function
        if let Expr::Call(call_expr) = expr {
            if let Some(arrow) = try_convert_bind_this(call_expr) {
                *expr = Expr::Arrow(arrow);
            }
        }
    }

    fn visit_mut_var_declarator(&mut self, decl: &mut VarDeclarator) {
        decl.name.visit_mut_with(self);
        let is_constructed_binding =
            declarator_binds_constructed_name(decl, self.constructed_bindings);
        let Some(init) = &mut decl.init else {
            return;
        };

        if is_constructed_binding {
            visit_fn_body_without_converting(init, self);
            return;
        }

        init.visit_mut_with(self);
    }

    fn visit_mut_assign_expr(&mut self, expr: &mut AssignExpr) {
        expr.left.visit_mut_with(self);
        if assign_target_is_constructed_name(&expr.left, self.constructed_bindings) {
            visit_fn_body_without_converting(&mut expr.right, self);
            return;
        }
        expr.right.visit_mut_with(self);
    }

    fn visit_mut_key_value_prop(&mut self, prop: &mut KeyValueProp) {
        // Object property function values are handled by ObjMethodShorthand.
        // ArrowFunction must not convert them to arrows — that would produce
        // `{"foo": () => {}}` which is not method syntax.
        // We still recurse into the function body so inner expressions are processed.
        prop.key.visit_mut_with(self);
        if let Expr::Fn(fn_expr) = prop.value.as_mut() {
            if let Some(body) = &mut fn_expr.function.body {
                body.visit_mut_with(self);
            }
        } else {
            prop.value.visit_mut_with(self);
        }
    }

    fn visit_mut_export_default_expr(
        &mut self,
        export: &mut swc_core::ecma::ast::ExportDefaultExpr,
    ) {
        // A default-exported function expression remains constructable by
        // consumers. Converting it to an arrow would remove its prototype.
        if let Expr::Fn(fn_expr) = export.expr.as_mut() {
            if let Some(body) = &mut fn_expr.function.body {
                body.visit_mut_with(self);
            }
        } else {
            export.expr.visit_mut_with(self);
        }
    }
}

fn collect_constructed_bindings(module: &Module) -> HashSet<BindingId> {
    BindingUseIndex::collect(module).new_callee_bindings()
}

fn declarator_binds_constructed_name(
    decl: &VarDeclarator,
    constructed_bindings: &HashSet<BindingId>,
) -> bool {
    let Pat::Ident(binding) = &decl.name else {
        return false;
    };
    constructed_bindings.contains(&(binding.id.sym.clone(), binding.id.ctxt))
}

fn assign_target_is_constructed_name(
    target: &AssignTarget,
    constructed_bindings: &HashSet<BindingId>,
) -> bool {
    let AssignTarget::Simple(SimpleAssignTarget::Ident(binding)) = target else {
        return false;
    };
    constructed_bindings.contains(&(binding.id.sym.clone(), binding.id.ctxt))
}

fn visit_fn_body_without_converting(expr: &mut Expr, converter: &mut ArrowFunctionConverter<'_>) {
    if let Expr::Fn(fn_expr) = expr {
        if let Some(body) = &mut fn_expr.function.body {
            body.visit_mut_with(converter);
        }
    } else {
        expr.visit_mut_with(converter);
    }
}

fn try_convert_to_arrow(fn_expr: &mut FnExpr) -> Option<ArrowExpr> {
    let func = &fn_expr.function;

    // Don't convert generators
    if func.is_generator {
        return None;
    }

    // Named function expressions expose the name through `.name`. Converting
    // them to arrows can erase or change that observable value.
    if fn_expr.ident.is_some() {
        return None;
    }

    // Arrow parameter lists reject duplicate names as an early error; a
    // sloppy-mode function may carry them.
    if has_duplicate_param_names(&func.params) {
        return None;
    }

    // Must have a body
    let body = func.body.as_ref()?;

    // Direct eval can observe function-only bindings (`this`, `arguments`,
    // `new.target`) that are not visible to an AST walk of the containing
    // function. Keep the function shape rather than guessing from source text.
    if body_has_arrow_sensitive_direct_eval(body, true) {
        return None;
    }

    // Check for this or arguments usage (don't recurse into nested functions)
    let mut checker = HasThisOrArguments(false);
    body.visit_with(&mut checker);
    if checker.0 {
        return None;
    }

    // Convert params: Vec<Param> -> Vec<Pat>
    let params: Vec<Pat> = fn_expr
        .function
        .params
        .iter()
        .map(|p| p.pat.clone())
        .collect();

    // Build the arrow body
    let arrow_body = build_arrow_body(&fn_expr.function);

    Some(ArrowExpr {
        span: DUMMY_SP,
        ctxt: SyntaxContext::empty(),
        params,
        body: Box::new(arrow_body),
        is_async: fn_expr.function.is_async,
        is_generator: false,
        type_params: fn_expr.function.type_params.take(),
        return_type: fn_expr.function.return_type.take(),
    })
}

/// Build the arrow body:
/// - Always keep the original block body.
/// - ArrowReturn is responsible for `{ return expr; }` → `expr`.
fn build_arrow_body(func: &Function) -> BlockStmtOrExpr {
    let body = match func.body.as_ref() {
        Some(b) => b,
        None => return BlockStmtOrExpr::BlockStmt(Default::default()),
    };

    BlockStmtOrExpr::BlockStmt(body.clone())
}

/// Try to convert `fn.bind(this)` to an arrow function.
/// Only fires when args is exactly `[this]` (no partial application).
/// The function may use `this` — that's the whole point of `.bind(this)`.
/// Still rejects: named functions, generators, functions using `arguments`.
fn try_convert_bind_this(call: &CallExpr) -> Option<ArrowExpr> {
    // Callee must be `expr.bind`
    let Callee::Expr(callee_expr) = &call.callee else {
        return None;
    };
    let Expr::Member(member) = callee_expr.as_ref() else {
        return None;
    };
    let MemberProp::Ident(prop) = &member.prop else {
        return None;
    };
    if prop.sym != "bind" {
        return None;
    }

    // Must have exactly one argument and it must be `this` (no partial application)
    if call.args.len() != 1 || call.args[0].spread.is_some() {
        return None;
    }
    if !matches!(call.args[0].expr.as_ref(), Expr::This(_)) {
        return None;
    }

    // The bound expression must be a function expression
    let Expr::Fn(fn_expr) = member.obj.as_ref() else {
        return None;
    };
    let func = &fn_expr.function;

    // Reject generators and named function expressions
    if func.is_generator || fn_expr.ident.is_some() {
        return None;
    }

    // Arrow parameter lists reject duplicate names as an early error.
    if has_duplicate_param_names(&func.params) {
        return None;
    }

    if func
        .body
        .as_ref()
        .is_some_and(|body| body_has_arrow_sensitive_direct_eval(body, false))
    {
        return None;
    }

    // Reject functions that use `arguments` (arrows have no own `arguments`)
    let mut has_args = HasArguments(false);
    if let Some(body) = &func.body {
        body.visit_with(&mut has_args);
    }
    if has_args.0 {
        return None;
    }

    let params: Vec<Pat> = func.params.iter().map(|p| p.pat.clone()).collect();
    let arrow_body = build_arrow_body(func);

    Some(ArrowExpr {
        span: DUMMY_SP,
        ctxt: SyntaxContext::empty(),
        params,
        body: Box::new(arrow_body),
        is_async: func.is_async,
        is_generator: false,
        type_params: func.type_params.clone(),
        return_type: func.return_type.clone(),
    })
}

fn body_has_arrow_sensitive_direct_eval(body: &BlockStmt, include_this: bool) -> bool {
    let mut analyzer = ArrowSensitiveDirectEvalAnalyzer::default();
    body.visit_with(&mut analyzer);
    if analyzer.unknown_direct_eval {
        return true;
    }

    // `new` is deliberately broader than the exact `new.target` spelling so
    // whitespace/comments in evaluated source cannot evade the guard.
    let arguments_name: Atom = "arguments".into();
    let new_name: Atom = "new".into();
    let this_name: Atom = "this".into();
    analyzer.known_direct_eval_sources.iter().any(|source| {
        js_source_mentions_binding(source, &arguments_name)
            || js_source_mentions_binding(source, &new_name)
            || (include_this && js_source_mentions_binding(source, &this_name))
    })
}

#[derive(Default)]
struct ArrowSensitiveDirectEvalAnalyzer {
    known_direct_eval_sources: Vec<String>,
    unknown_direct_eval: bool,
}

impl Visit for ArrowSensitiveDirectEvalAnalyzer {
    fn visit_call_expr(&mut self, expr: &CallExpr) {
        if let Some(source) = direct_eval_call_source(expr) {
            match source {
                EvalCallSource::NoSource => {}
                EvalCallSource::Known(source) => self.known_direct_eval_sources.push(source),
                EvalCallSource::Unknown => self.unknown_direct_eval = true,
            }
            for arg in &expr.args {
                arg.expr.visit_with(self);
            }
            return;
        }

        expr.visit_children_with(self);
    }

    // Regular functions have their own `this`, `arguments`, and `new.target`.
    // Arrows still recurse through the default visitor because they capture
    // those bindings from the function being considered for conversion.
    fn visit_function(&mut self, _: &Function) {}
}

// ============================================================
// Visitor: check for `this` or `arguments` (not in nested fns)
// ============================================================

struct HasThisOrArguments(bool);

impl Visit for HasThisOrArguments {
    fn visit_this_expr(&mut self, _: &ThisExpr) {
        self.0 = true;
    }

    fn visit_ident(&mut self, id: &Ident) {
        if id.sym == "arguments" {
            self.0 = true;
        }
    }

    // Don't recurse into nested functions — they have their own this/arguments
    fn visit_function(&mut self, _: &Function) {}

    // Recurse into arrow expressions because they capture both `this` and
    // `arguments` from this function.
}

// ============================================================
// Visitor: check for `arguments` only (not `this`)
// ============================================================

struct HasArguments(bool);

impl Visit for HasArguments {
    fn visit_ident(&mut self, id: &Ident) {
        if id.sym == "arguments" {
            self.0 = true;
        }
    }

    fn visit_function(&mut self, _: &Function) {}
}