crates/core/tests/arg_rest_rule.rs
GitHubmod common;
use common::{assert_eq_normalized, render_rule};
use swc_core::common::{sync::Lrc, FileName, Mark, SourceMap, SyntaxContext, GLOBALS};
use swc_core::ecma::ast::{BindingIdent, Decl, EsVersion, Function, ModuleItem, Pat, Stmt};
use swc_core::ecma::parser::{lexer::Lexer, EsSyntax, Parser, StringInput, Syntax};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::visit::VisitMutWith;
use wakaru_core::{rules::ArgRest, RewriteLevel};
fn apply(input: &str) -> String {
apply_with_level(input, RewriteLevel::Standard)
}
fn apply_with_level(input: &str, level: RewriteLevel) -> String {
render_rule(input, |_| ArgRest::new(level))
}
#[test]
fn arguments_index_becomes_rest_args() {
let input = r#"
function foo() {
return arguments[0] + arguments[1];
}
"#;
let expected = r#"
function foo(...args) {
return args[0] + args[1];
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn minimal_does_not_convert_arguments_index_to_rest_args() {
let input = r#"
function foo() {
return arguments[0] + arguments[1];
}
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn arguments_length_becomes_rest_length() {
let input = r#"
function foo() {
return arguments.length;
}
"#;
let expected = r#"
function foo(...args) {
return args.length;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn arguments_loop_pattern() {
let input = r#"
function sum() {
var total = 0;
for (var i = 0; i < arguments.length; i++) {
total += arguments[i];
}
return total;
}
"#;
let expected = r#"
function sum(...args) {
var total = 0;
for (var i = 0; i < args.length; i++) {
total += args[i];
}
return total;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn arguments_with_variable_index() {
let input = r#"
function get(i) {
return arguments[i];
}
"#;
// Function has a formal param — should not transform
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn parameterless_variable_index_without_length_guard_not_converted() {
let input = r#"
function get() {
var i = chooseIndex();
return arguments[i];
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn shadowed_loop_index_is_not_treated_as_length_guarded() {
let input = r#"
function get() {
for (var i = 0; i < arguments.length; i++) {
{
let i = chooseIndex();
return arguments[i];
}
}
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn length_guarded_post_increment_index_becomes_rest_args() {
let input = r#"
function join() {
var out = "";
for (var i = 0; i < arguments.length;) {
out += arguments[i++];
}
return out;
}
"#;
let expected = r#"
function join(...args) {
var out = "";
for (var i = 0; i < args.length;) {
out += args[i++];
}
return out;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn cached_arguments_length_loop_index_becomes_rest_args() {
let input = r#"
function join() {
const len = arguments.length;
var out = "";
for (var i = 0; i < len; i++) {
out += arguments[i];
}
return out;
}
"#;
let expected = r#"
function join(...args) {
const len = args.length;
var out = "";
for (var i = 0; i < len; i++) {
out += args[i];
}
return out;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn while_loop_with_length_guarded_post_increment_index_becomes_rest_args() {
let input = r#"
function join() {
var out = "";
let i = 0;
while (i < arguments.length) {
out += arguments[i++];
}
return out;
}
"#;
let expected = r#"
function join(...args) {
var out = "";
let i = 0;
while (i < args.length) {
out += args[i++];
}
return out;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn for_loop_init_arguments_length_alias_becomes_rest_args() {
let input = r#"
function join() {
var out = "";
for (var i = 0, len = arguments.length; i < len; i++) {
out += arguments[i];
}
return out;
}
"#;
let expected = r#"
function join(...args) {
var out = "";
for (var i = 0, len = args.length; i < len; i++) {
out += args[i];
}
return out;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn function_with_params_not_converted() {
// Accessing the fixed-parameter prefix through `arguments` is still unsafe.
let input = r#"
function foo(a, b) {
return arguments[0];
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn function_with_fixed_params_tail_indices_becomes_rest_args() {
let input = r#"
function foo(a, b) {
return arguments[2] + arguments[3];
}
"#;
let expected = r#"
function foo(a, b, ...args) {
return args[0] + args[1];
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn function_already_has_rest_not_converted() {
let input = r#"
function foo(...rest) {
return rest[0];
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn bare_arguments_reference_not_converted() {
// Passing `arguments` as a whole value is unsafe to transform
let input = r#"
function foo() {
return bar(arguments);
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn arguments_spread_not_converted() {
let input = r#"
function foo() {
return bar(...arguments);
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn nested_function_arguments_not_conflated() {
// Inner function's `arguments` should be transformed independently;
// outer function has no `arguments` so it is left alone.
let input = r#"
function outer() {
function inner() {
return arguments[0];
}
return inner;
}
"#;
let expected = r#"
function outer() {
function inner(...args) {
return args[0];
}
return inner;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn no_arguments_usage_not_converted() {
let input = r#"
function foo() {
return 42;
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
// ---------------------------------------------------------------------------
// Class constructor support
// ---------------------------------------------------------------------------
#[test]
fn constructor_arguments_becomes_rest_param() {
// ArgRest must also visit Constructor nodes, not just Function nodes
let input = r#"
class Foo {
constructor() {
console.log(arguments[0]);
}
}
"#;
let expected = r#"
class Foo {
constructor(...args) {
console.log(args[0]);
}
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn constructor_babel_copy_loop_removed() {
// The Babel rest-args copy loop should be removed when rest param is added
let input = r#"
class Foo {
constructor() {
for (var o = arguments.length, i = Array(o), a = 0; a < o; a++) {
i[a] = arguments[a];
}
this.items = i;
}
}
"#;
let expected = r#"
class Foo {
constructor(...i) {
this.items = i;
}
}
"#;
assert_eq_normalized(&apply(input), expected);
}
// ---------------------------------------------------------------------------
// Copy loop removal in regular functions
// ---------------------------------------------------------------------------
#[test]
fn function_babel_copy_loop_removed() {
let input = r#"
function foo() {
for (var len = arguments.length, args = Array(len), i = 0; i < len; i++) {
args[i] = arguments[i];
}
return args;
}
"#;
let expected = r#"
function foo(...args) {
return args;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn function_babel_tail_copy_loop_removed() {
let input = r#"
function foo(a, b) {
for (var len = arguments.length, rest = Array(len > 2 ? len - 2 : 0), i = 2; i < len; i++) {
rest[i - 2] = arguments[i];
}
return bar(a, b, rest);
}
"#;
let expected = r#"
function foo(a, b, ...rest) {
return bar(a, b, rest);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn function_typescript_tail_copy_loop_removed() {
let input = r#"
function collect(first) {
var rest_items = [];
for (var _i = 1; _i < arguments.length; _i++) {
rest_items[_i - 1] = arguments[_i];
}
return use(first, rest_items);
}
"#;
let expected = r#"
function collect(first, ...rest_items) {
return use(first, rest_items);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn function_typescript_tail_copy_loop_with_offset_removed() {
let input = r#"
function collect(app_id, version) {
var rest_items = [];
for (var _i = 2; _i < arguments.length; _i++) {
rest_items[_i - 2] = arguments[_i];
}
return use(app_id, version, rest_items);
}
"#;
let expected = r#"
function collect(app_id, version, ...rest_items) {
return use(app_id, version, rest_items);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn tail_copy_loop_with_wrong_test_is_preserved() {
let input = r#"
function foo(a, b) {
for (var len = arguments.length, rest = Array(len > 2 ? len - 2 : 0), i = 2; i <= len; i++) {
rest[i - 2] = arguments[i];
}
return rest;
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn tail_copy_loop_with_wrong_write_index_is_preserved() {
let input = r#"
function foo(a, b) {
for (var len = arguments.length, rest = Array(len > 2 ? len - 2 : 0), i = 2; i < len; i++) {
rest[i] = arguments[i];
}
return rest;
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn tail_copy_loop_with_extra_body_statement_is_preserved() {
let input = r#"
function foo(a, b) {
for (var len = arguments.length, rest = Array(len > 2 ? len - 2 : 0), i = 2; i < len; i++) {
rest[i - 2] = arguments[i];
observe(arguments.callee);
}
return rest;
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn copy_loop_preserved_when_not_arguments_pattern() {
// A for loop that doesn't match the Babel copy pattern should be kept
let input = r#"
function foo() {
for (var i = 0; i < 10; i++) {
console.log(arguments[i]);
}
}
"#;
let output = apply(input);
assert_eq_normalized(&output, input);
}
#[test]
fn copy_loop_rest_param_preserves_binding_context() {
let input = r#"
function foo(a) {
for (var _len = arguments.length, _args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
_args[_key - 1] = arguments[_key];
}
console.log(_args);
}
"#;
let (copy_var_ctxt, rest_param_ctxt) = rest_param_context_from_copy_loop(input);
assert_eq!(
rest_param_ctxt, copy_var_ctxt,
"rest parameter should keep the binding context from the consumed copy variable"
);
assert_ne!(
rest_param_ctxt,
SyntaxContext::empty(),
"regression input should use a scoped local binding"
);
}
fn rest_param_context_from_copy_loop(input: &str) -> (SyntaxContext, SyntaxContext) {
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let fm = cm.new_source_file(
FileName::Custom("fixture.js".to_string()).into(),
input.to_string(),
);
let lexer = Lexer::new(
Syntax::Es(EsSyntax::default()),
EsVersion::latest(),
StringInput::from(&*fm),
None,
);
let mut parser = Parser::new_from(lexer);
let mut module = parser.parse_module().expect("input should parse");
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
let copy_var_ctxt = for_loop_copy_var_context(first_function(&module).function.as_ref());
module.visit_mut_with(&mut ArgRest::new(RewriteLevel::Standard));
let rest_param_ctxt = last_rest_param_context(first_function(&module).function.as_ref());
(copy_var_ctxt, rest_param_ctxt)
})
}
fn first_function(module: &swc_core::ecma::ast::Module) -> &swc_core::ecma::ast::FnDecl {
let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(function))) = &module.body[0] else {
panic!("expected function declaration");
};
function
}
fn for_loop_copy_var_context(function: &Function) -> SyntaxContext {
let body = function.body.as_ref().expect("expected function body");
let Stmt::For(for_stmt) = &body.stmts[0] else {
panic!("expected for statement");
};
let Some(swc_core::ecma::ast::VarDeclOrExpr::VarDecl(init)) = &for_stmt.init else {
panic!("expected var decl in for init");
};
let Pat::Ident(BindingIdent { id, .. }) = &init.decls[1].name else {
panic!("expected identifier for copy var (second declarator)");
};
id.ctxt
}
fn last_rest_param_context(function: &Function) -> SyntaxContext {
let last_param = function.params.last().expect("expected at least one param");
let Pat::Rest(rest) = &last_param.pat else {
panic!("expected rest parameter");
};
let Pat::Ident(BindingIdent { id, .. }) = rest.arg.as_ref() else {
panic!("expected identifier in rest parameter");
};
id.ctxt
}