crates/core/tests/un_parameters_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::UnParameters, RewriteLevel};
fn apply(input: &str) -> String {
apply_with_level(input, RewriteLevel::Standard)
}
fn apply_with_level(input: &str, level: RewriteLevel) -> String {
render_rule(input, |unresolved_mark| {
UnParameters::new(unresolved_mark, level)
})
}
// --- void 0 / undefined guard patterns ---
#[test]
fn void0_guard_becomes_default_param() {
let input = r#"
function foo(a, b) {
if (a === void 0) { a = 1; }
if (b === void 0) b = 2;
return a + b;
}
"#;
let expected = r#"
function foo(a = 1, b = 2) {
return a + b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn void0_guard_reversed_operands() {
let input = r#"
function foo(a, b) {
if (void 0 === a) a = 1;
if (void 0 === b) { b = 2; }
return a + b;
}
"#;
let expected = r#"
function foo(a = 1, b = 2) {
return a + b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn undefined_guard_becomes_default_param() {
let input = r#"
function foo(a, b) {
if (a === undefined) a = 1;
if (undefined === b) b = 2;
return a + b;
}
"#;
let expected = r#"
function foo(a = 1, b = 2) {
return a + b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn shadowed_undefined_guard_stays_in_body() {
let input = r#"
function foo(a) {
var undefined = 42;
if (a === undefined) a = 1;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn duplicate_param_void0_guard_stays_in_body() {
let input = r#"
function foo(a, a) {
if (a === void 0) a = 1;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn void0_guard_in_arrow_function() {
let input = r#"
const test = (a, b) => {
if (a === void 0) a = 1;
if (void 0 === b) b = 2;
};
"#;
let expected = r#"
const test = (a = 1, b = 2) => {};
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn default_guard_referencing_later_param_stays_in_body() {
let input = r#"
function foo(a, b) {
if (a === void 0) a = b.value;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn arrow_default_guard_referencing_later_param_stays_in_body() {
let input = r#"
const foo = (a, b) => {
if (a === void 0) a = b.value;
return a;
};
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn default_guard_referencing_same_param_stays_in_body() {
let input = r#"
function foo(a) {
if (a === void 0) a = a;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn default_guard_referencing_body_var_stays_in_body() {
let input = r#"
function foo(a) {
if (a === void 0) a = x;
var x = 1;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn default_guard_referencing_earlier_body_var_stays_in_body() {
let input = r#"
function foo(a) {
var x = 1;
if (a === void 0) a = x;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn arrow_default_guard_referencing_body_var_stays_in_body() {
let input = r#"
const foo = (a) => {
if (a === void 0) a = x;
var x = 1;
return a;
};
"#;
assert_eq_normalized(&apply(input), input);
}
// --- falsy-coalescing patterns are intentionally not rewritten ---
#[test]
fn or_assignment_stays_as_is() {
let input = r#"
function foo(a) {
a = a || 2;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn or_assignment_multiple_params_stay_as_is() {
let input = r#"
function foo(a, b, c) {
a = a || "hello";
b = b || {};
c = c || [];
}
"#;
assert_eq_normalized(&apply(input), input);
}
// --- ternary-assignment pattern ---
#[test]
fn ternary_self_check_stays_as_is() {
let input = r#"
function foo(a) {
a = a ? a : 4;
}
"#;
assert_eq_normalized(&apply(input), input);
}
// --- known-broken semantic regressions ---
#[test]
fn known_bug_or_assignment_with_zero_not_converted() {
let input = r#"
function foo(a) {
a = a || 2;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn known_bug_ternary_self_check_with_empty_string_not_converted() {
let input = r#"
function foo(a) {
a = a ? a : "fallback";
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
// --- no-op cases ---
#[test]
fn noop_no_guard() {
let input = r#"
function foo(a, b) {
return a + b;
}
"#;
let expected = r#"
function foo(a, b) {
return a + b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn noop_guard_for_non_param() {
// `c` is not in the parameter list — guard should be left untouched
let input = r#"
function foo(a, b) {
if (c === void 0) c = 1;
return a + b;
}
"#;
let expected = r#"
function foo(a, b) {
if (c === void 0) c = 1;
return a + b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn arguments_boolean_presence_default_becomes_param_default() {
let input = r#"
function foo(a) {
var b = !(arguments.length > 1 && arguments[1] !== undefined) || arguments[1];
return b;
}
"#;
let expected = r#"
function foo(a, b = true) {
return b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn shadowed_arguments_param_stays_in_body() {
let input = r#"
function foo(arguments) {
var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
return b;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn minimal_does_not_recover_arguments_boolean_presence_default() {
let input = r#"
function foo(a) {
var b = !(arguments.length > 1 && arguments[1] !== undefined) || arguments[1];
return b;
}
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn arguments_inline_default_expression_becomes_param_default() {
let input = r#"
function foo(a, b) {
return bar(a, b, arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null);
}
"#;
let expected = r#"
function foo(a, b, _param_2 = null) {
return bar(a, b, _param_2);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn inline_arguments_defaults_use_unused_empty_decl_names() {
let input = r#"
function greet() {
let name, count;
return use(
arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "world",
arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1
);
}
"#;
let expected = r#"
function greet(name = "world", count = 1) {
return use(name, count);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn inline_arguments_optional_alias_uses_unused_empty_decl_name() {
let input = r#"
function range() {
let start, end;
return use(
arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0,
arguments.length > 1 ? arguments[1] : undefined
);
}
"#;
let expected = r#"
function range(start = 0, end) {
return use(start, end);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn inline_arguments_default_keeps_referenced_empty_decl_name() {
let input = r#"
function foo() {
let name;
return use(
name,
arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "world"
);
}
"#;
let expected = r#"
function foo(_param_0 = "world") {
let name;
return use(name, _param_0);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn minimal_does_not_recover_inline_arguments_default_expression() {
let input = r#"
function foo(a, b) {
return bar(a, b, arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null);
}
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn arguments_alias_becomes_plain_param() {
let input = r#"
function foo(a) {
const b = arguments[1];
return b;
}
"#;
let expected = r#"
function foo(a, b) {
return b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn optional_arguments_alias_becomes_plain_param() {
let input = r#"
function foo(a) {
let b = arguments.length > 1 ? arguments[1] : undefined;
return b;
}
"#;
let expected = r#"
function foo(a, b) {
return b;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn minimal_does_not_recover_optional_arguments_alias() {
let input = r#"
function foo(a) {
let b = arguments.length > 1 ? arguments[1] : undefined;
return b;
}
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn arguments_alias_to_existing_param_name_stays_in_body() {
let input = r#"
function foo(a) {
const b = arguments[0];
return b;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn arguments_default_to_existing_param_name_stays_in_body() {
let input = r#"
function foo(a) {
var b = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
return b;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn arguments_default_referencing_later_param_stays_in_body() {
let input = r#"
function foo(q, K, _, z) {
var q = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _.bits || 2048;
var K = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _.e || 65537;
return [q, K, _, z];
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn arguments_default_referencing_same_param_stays_in_body() {
let input = r#"
function foo(a) {
var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : a;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn arguments_default_referencing_body_var_stays_in_body() {
let input = r#"
function foo(a) {
var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : x;
var x = 1;
return a;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn inline_arguments_default_referencing_body_var_stays_in_body() {
let input = r#"
function foo() {
return arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : x;
var x = 1;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn undefined_object_alias_becomes_default_param() {
let input = r#"
function foo(options) {
const opts = options === undefined ? {} : options;
return opts.name;
}
"#;
let expected = r#"
function foo(options = {}) {
const opts = options;
return opts.name;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn duplicate_param_object_alias_default_stays_in_body() {
let input = r#"
function foo(options, options) {
const opts = options === undefined ? {} : options;
return opts.name;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn minimal_does_not_recover_undefined_object_alias_default() {
let input = r#"
function foo(options) {
const opts = options === undefined ? {} : options;
return opts.name;
}
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn undefined_object_destructuring_keeps_body_defaults() {
let input = r#"
function foo(options) {
const { name = fallback } = options === undefined ? {} : options;
const fallback = "x";
return name;
}
"#;
let expected = r#"
function foo(options = {}) {
const { name = fallback } = options;
const fallback = "x";
return name;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn undefined_object_alias_arrow_becomes_default_param() {
let input = r#"
const foo = (options) => {
const opts = options === undefined ? {} : options;
return opts.name;
};
"#;
let expected = r#"
const foo = (options = {}) => {
const opts = options;
return opts.name;
};
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_destructuring_alias_becomes_param_pattern() {
let input = r#"
function foo(_ref) {
const { name, age = fallback } = _ref;
return name + age;
}
"#;
let expected = r#"
function foo({ name, age = fallback }) {
return name + age;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_destructuring_alias_default_becomes_param_pattern_default() {
let input = r#"
function foo(_ref) {
const { name = fallback } = _ref === undefined ? {} : _ref;
return name;
}
"#;
let expected = r#"
function foo({ name = fallback } = {}) {
return name;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_aliases_become_param_pattern() {
let input = r#"
function pick(_ref = {}) {
let name = _ref.name;
let _ref$age = _ref.age;
let age = _ref$age === undefined ? 0 : _ref$age;
return use(name, age);
}
"#;
let expected = r#"
function pick({ name, age = 0 } = {}) {
return use(name, age);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn computed_object_property_alias_becomes_param_pattern() {
let input = r#"
function pick(property_key, _ref = {}) {
let _ref$property_key = _ref[property_key];
let value = _ref$property_key === undefined ? fallback : _ref$property_key;
return use(value);
}
"#;
let expected = r#"
function pick(property_key, { [property_key]: value = fallback } = {}) {
return use(value);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn computed_object_property_through_generated_default_alias_becomes_param_pattern() {
let input = r#"
function pick(property_key, _temp) {
let _ref = _temp === undefined ? {} : _temp;
let _ref$property_key = _ref[property_key];
let value = _ref$property_key === undefined ? fallback : _ref$property_key;
return use(value);
}
"#;
let expected = r#"
function pick(property_key, { [property_key]: value = fallback } = {}) {
return use(value);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn computed_object_property_alias_before_later_param_stays_in_body() {
let input = r#"
function pick(property_key, _ref = {}, later = (property_key = "other")) {
let _ref$property_key = _ref[property_key];
let value = _ref$property_key === undefined ? fallback : _ref$property_key;
return use(value, later);
}
"#;
let expected = r#"
function pick(property_key, _ref = {}, later = property_key = "other") {
let _ref$property_key = _ref[property_key];
let value = _ref$property_key === undefined ? fallback : _ref$property_key;
return use(value, later);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn computed_object_property_alias_with_non_param_key_stays_in_body() {
let input = r#"
function pick(_ref = {}) {
let _ref$property_key = _ref[property_key];
let value = _ref$property_key === undefined ? fallback : _ref$property_key;
return use(value);
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn object_property_inline_default_aliases_become_param_pattern() {
let input = r#"
function pick(_ref = {}) {
let name = _ref.name;
let _ref$age = _ref.age;
let age;
return use(name, _ref$age === undefined ? 0 : _ref$age);
}
"#;
let expected = r#"
function pick({ name, age = 0 } = {}) {
return use(name, age);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn arguments_object_property_inline_default_aliases_become_param_pattern() {
let input = r#"
function pick() {
let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
let name = _ref.name;
let _ref$age = _ref.age;
let age;
return use(name, _ref$age === undefined ? 0 : _ref$age);
}
"#;
let expected = r#"
function pick({ name, age = 0 } = {}) {
return use(name, age);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn arguments_object_property_default_alias_becomes_param_pattern() {
let input = r#"
function config() {
let _ref$mode = (arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}).mode;
let appMode;
return use(_ref$mode === undefined ? "prod" : _ref$mode);
}
"#;
let expected = r#"
function config({ mode: appMode = "prod" } = {}) {
return use(appMode);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn generated_param_object_property_default_alias_becomes_param_pattern() {
let input = r#"
function config(_param_0 = {}) {
let _ref$mode = _param_0.mode;
let appMode;
return use(_ref$mode === undefined ? "prod" : _ref$mode);
}
"#;
let expected = r#"
function config({ mode: appMode = "prod" } = {}) {
return use(appMode);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn conditional_object_property_default_alias_becomes_param_pattern() {
let input = r#"
function config(_temp) {
let _ref;
let _ref$mode = (_temp === undefined ? {} : _temp).mode;
let appMode;
return use(_ref$mode === undefined ? "prod" : _ref$mode);
}
"#;
let expected = r#"
function config({ mode: appMode = "prod" } = {}) {
return use(appMode);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn const_conditional_object_property_default_alias_becomes_param_pattern() {
let input = r#"
function config(_a) {
let _b;
const mode = (_a === undefined ? {} : _a).mode;
const appMode = mode === undefined ? "prod" : mode;
return use(appMode);
}
"#;
let expected = r#"
function config({ mode: appMode = "prod" } = {}) {
return use(appMode);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_alias_with_rename_becomes_param_pattern() {
let input = r#"
function config(_ref = {}) {
let appMode = _ref.mode;
return use(appMode);
}
"#;
let expected = r#"
function config({ mode: appMode } = {}) {
return use(appMode);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_short_alias_renames_to_property_name() {
let input = r#"
function reducer(e = s, t = {}) {
var n = t.type;
var r = t.payload;
if (n === LOCATION_CHANGE) {
return {
...e,
location: r
};
}
return e;
}
"#;
let expected = r#"
function reducer(e = s, { type, payload: r } = {}) {
if (type === LOCATION_CHANGE) {
return {
...e,
location: r
};
}
return e;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_numbered_generated_alias_renames_to_property_name() {
let input = r#"
function reducer(e = s, t = {}) {
var ab1 = t.type;
if (ab1 === LOCATION_CHANGE) {
return e;
}
return e;
}
"#;
let expected = r#"
function reducer(e = s, { type } = {}) {
if (type === LOCATION_CHANGE) {
return e;
}
return e;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_short_alias_rename_avoids_nested_capture() {
let input = r#"
function reducer(t = {}) {
var n = t.type;
return function(type) {
return n + type;
};
}
"#;
let expected = r#"
function reducer({ type: n } = {}) {
return function(type) {
return n + type;
};
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_aliases_keep_body_when_param_used_later() {
let input = r#"
function config(e) {
const key = e.key;
if (key === "css") {
return e.container;
}
return use(e.nonce, key);
}
"#;
let expected = r#"
function config(e) {
const key = e.key;
if (key === "css") {
return e.container;
}
return use(e.nonce, key);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn object_property_aliases_keep_uninit_locals_used_in_closure() {
let input = r#"
function U(e, t, n, r, o) {
var i;
var a;
var u;
var l;
var c;
var s = o.areStatesEqual;
var f = o.areOwnPropsEqual;
var d = o.areStatePropsEqual;
var p = false;
function h(o, p) {
const h = !f(p, a);
const m = !s(o, i);
i = o;
a = p;
u = e(i, a);
l = t(r, a);
return c = n(u, l, a);
}
return function(o, s) {
return p ? h(o, s) : c;
};
}
"#;
let expected = input;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn nested_object_destructuring_alias_becomes_param_pattern() {
let input = r#"
function nested(_ref = {}) {
const { outer: { value = fallbackValue } = {} } = _ref;
return value;
}
"#;
let expected = r#"
function nested({ outer: { value = fallbackValue } = {} } = {}) {
return value;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn nested_object_reassignment_default_folds_into_param() {
// Babel 7.8 spec output: reassigns the destructured binding instead of
// using a fresh temp, so the default appears as a body ExprStmt rather
// than a VarDecl initializer.
let input = r#"
function nested({ outer: _ref$outer } = {}) {
_ref$outer = _ref$outer === undefined ? {} : _ref$outer;
let _ref$outer$value = _ref$outer.value;
let value = _ref$outer$value === undefined ? fallbackValue : _ref$outer$value;
return use(value);
}
"#;
let expected = r#"
function nested({ outer: { value = fallbackValue } = {} } = {}) {
return use(value);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn nested_object_reassignment_default_no_inner_props() {
// Same reassignment pattern but without further property accesses —
// just promote the default.
let input = r#"
function nested({ outer: _ref$outer } = {}) {
_ref$outer = _ref$outer === undefined ? {} : _ref$outer;
return use(_ref$outer);
}
"#;
let expected = r#"
function nested({ outer: _ref$outer = {} } = {}) {
return use(_ref$outer);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn nested_object_reassignment_default_skipped_when_binding_used_after() {
// The binding is used after the reassignment AND in property accesses,
// so removing the reassignment would change semantics.
let input = r#"
function nested({ outer: _ref$outer } = {}) {
_ref$outer = _ref$outer === undefined ? {} : _ref$outer;
let val = _ref$outer.value;
log(_ref$outer);
return use(val);
}
"#;
let expected = r#"
function nested({ outer: _ref$outer = {} } = {}) {
let val = _ref$outer.value;
log(_ref$outer);
return use(val);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn pattern_c_dead_alias_inlined_enables_nested_folding() {
// Babel 7.8 loose: Pattern C promotes the default but leaves a dead
// alias `let _ref = _temp`. Inlining it lets property folding proceed.
let input = r#"
function nested(_temp) {
let _ref = _temp === void 0 ? {} : _temp;
let _ref$outer = _ref.outer;
_ref$outer = _ref$outer === void 0 ? {} : _ref$outer;
let _ref$outer$value = _ref$outer.value;
let value = _ref$outer$value === void 0 ? fallbackValue : _ref$outer$value;
return use(value);
}
"#;
let expected = r#"
function nested({ outer: { value = fallbackValue } = {} } = {}) {
return use(value);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn pattern_c_dead_alias_not_inlined_when_param_reassigned() {
// _temp is reassigned after the alias — inlining would lose the capture.
let input = r#"
function f(_temp) {
let _ref = _temp === void 0 ? {} : _temp;
_temp = other;
return use(_ref);
}
"#;
let expected = r#"
function f(_temp = {}) {
let _ref = _temp;
_temp = other;
return use(_ref);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn pattern_c_dead_alias_not_inlined_when_alias_reassigned() {
// _ref is reassigned — it's not a dead alias.
let input = r#"
function f(_temp) {
let _ref = _temp === void 0 ? {} : _temp;
_ref = modified;
return use(_ref);
}
"#;
let expected = r#"
function f(_temp = {}) {
let _ref = _temp;
_ref = modified;
return use(_ref);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn array_destructuring_alias_becomes_param_pattern() {
let input = r#"
function foo(_ref = []) {
const [first, second = fallback] = _ref;
return first + second;
}
"#;
let expected = r#"
function foo([first, second = fallback] = []) {
return first + second;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn array_destructuring_conditional_alias_becomes_param_pattern_default() {
let input = r#"
function foo(_ref) {
const [first, second = fallback] = _ref === undefined ? [] : _ref;
return first + second;
}
"#;
let expected = r#"
function foo([first, second = fallback] = []) {
return first + second;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn array_index_aliases_become_param_pattern() {
let input = r#"
function first(_ref = []) {
let head = _ref[0];
let _ref$ = _ref[1];
let second = _ref$ === undefined ? fallback : _ref$;
return use(head, second);
}
"#;
let expected = r#"
function first([head, second = fallback] = []) {
return use(head, second);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn array_index_aliases_keep_body_when_param_used_later() {
let input = r#"
function first(items) {
const head = items[0];
return use(head, items.length);
}
"#;
let expected = r#"
function first(items) {
const head = items[0];
return use(head, items.length);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn conditional_array_index_aliases_become_param_pattern() {
let input = r#"
function first(_ref) {
let head = (_ref === undefined ? [] : _ref)[0];
let _ref$ = _ref[1];
let second = _ref$ === undefined ? fallback : _ref$;
return use(head, second);
}
"#;
let expected = r#"
function first([head, second = fallback] = []) {
return use(head, second);
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn arrow_object_destructuring_alias_becomes_param_pattern() {
let input = r#"
const foo = (_ref) => {
const { name } = _ref;
return name;
};
"#;
let expected = r#"
const foo = ({ name }) => {
return name;
};
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn minimal_does_not_fold_destructured_param_alias() {
let input = r#"
function foo(_ref) {
const { name } = _ref;
return name;
}
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn destructured_param_alias_used_later_stays_in_body() {
let input = r#"
function foo(_ref) {
const { name } = _ref;
return _ref.name || name;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn destructured_param_alias_after_bare_decls_becomes_param_pattern() {
let input = r#"
function foo(_ref) {
let cache;
let state;
const { name, value = fallback } = _ref;
cache = {};
state = value;
return name;
}
"#;
let expected = r#"
function foo({ name, value = fallback }) {
let cache;
let state;
cache = {};
state = value;
return name;
}
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn destructured_param_alias_after_bare_decl_referencing_decl_stays_in_body() {
let input = r#"
function foo(_ref) {
let fallback;
const { value = fallback } = _ref;
return value;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn destructured_param_alias_used_in_default_stays_in_body() {
let input = r#"
function foo(_ref) {
const { name = _ref.name } = _ref;
return name;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn destructured_param_collision_stays_in_body() {
let input = r#"
function foo(name, _ref) {
const { name } = _ref;
return name;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn minimal_does_not_recover_undefined_object_alias_default_in_arrow() {
let input = r#"
const foo = (options) => {
const opts = options === undefined ? {} : options;
return opts.name;
};
"#;
assert_eq_normalized(&apply_with_level(input, RewriteLevel::Minimal), input);
}
#[test]
fn non_empty_object_default_stays_in_body() {
let input = r#"
function foo(options) {
const opts = options === undefined ? makeOptions() : options;
return opts.name;
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn inline_arguments_default_preserves_candidate_binding_context() {
let input = r#"
function greet() {
let name;
return arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "world";
}
"#;
let (candidate_ctxt, param_ctxt) = recovered_first_param_context(input);
assert_eq!(
param_ctxt, candidate_ctxt,
"recovered parameter should keep the resolver binding context from the consumed declaration"
);
assert_ne!(
param_ctxt,
SyntaxContext::empty(),
"regression input should use a scoped local binding"
);
}
fn recovered_first_param_context(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 {
jsx: true,
..Default::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 candidate_ctxt = first_body_var_context(first_function(&module).function.as_ref());
module.visit_mut_with(&mut UnParameters::new(
unresolved_mark,
RewriteLevel::Standard,
));
(
candidate_ctxt,
first_param_context(first_function(&module).function.as_ref()),
)
})
}
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 first_body_var_context(function: &Function) -> SyntaxContext {
let body = function.body.as_ref().expect("expected function body");
let Stmt::Decl(Decl::Var(var)) = &body.stmts[0] else {
panic!("expected first body statement to be a var declaration");
};
let Pat::Ident(BindingIdent { id, .. }) = &var.decls[0].name else {
panic!("expected identifier declaration");
};
id.ctxt
}
fn first_param_context(function: &Function) -> SyntaxContext {
let Pat::Assign(assign) = &function.params[0].pat else {
panic!("expected recovered default parameter");
};
let Pat::Ident(BindingIdent { id, .. }) = assign.left.as_ref() else {
panic!("expected identifier parameter");
};
id.ctxt
}