crates/core/tests/un_to_array_rule.rs
GitHubmod common;
use common::{assert_eq_normalized, render, render_rule};
use wakaru_core::rules::UnToArray;
fn apply(input: &str) -> String {
render_rule(input, UnToArray::new_with_mark)
}
#[test]
fn unwraps_swc_external_to_array_destructuring() {
// Isolated: the array-rest pattern already exists (UnDestructuring builds it
// in the full pipeline); UnToArray strips the helper and drops the import.
let input = r#"
import { _ as _to_array } from "@swc/helpers/_/_to_array";
var [first, ...rest_items] = _to_array(items);
use(first, rest_items);
"#;
let expected = r#"
var [first, ...rest_items] = items;
use(first, rest_items);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn unwraps_unaliased_swc_to_array() {
let input = r#"
import { _ } from "@swc/helpers/_/_to_array";
var [first, ...rest_items] = _(items);
use(first, rest_items);
"#;
let expected = r#"
var [first, ...rest_items] = items;
use(first, rest_items);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn unwraps_babel_runtime_to_array_default_import() {
let input = r#"
import _toArray from "@babel/runtime/helpers/toArray";
var [first, ...rest_items] = _toArray(items);
use(first, rest_items);
"#;
let expected = r#"
var [first, ...rest_items] = items;
use(first, rest_items);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn unwraps_babel_runtime_to_array_require() {
let input = r#"
var _toArray = require("@babel/runtime/helpers/toArray");
var [first, ...rest_items] = _toArray(items);
use(first, rest_items);
"#;
let expected = r#"
var [first, ...rest_items] = items;
use(first, rest_items);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn preserves_shadowed_require_to_array_runtime_import() {
let input = r#"
function require(path) {
return load(path);
}
var _toArray = require("@babel/runtime/helpers/toArray");
var [first, ...rest_items] = _toArray(items);
use(first, rest_items);
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn unwraps_array_destructuring_assignment_target() {
let input = r#"
import { _ as _to_array } from "@swc/helpers/_/_to_array";
[first, ...rest_items] = _to_array(items);
use(first, rest_items);
"#;
let expected = r#"
[first, ...rest_items] = items;
use(first, rest_items);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn preserves_helper_when_not_array_destructuring() {
// No array pattern -> the toArray wrapper is load-bearing (the binding may
// escape as a real array), so it must stay, and the import with it.
let input = r#"
import { _ as _to_array } from "@swc/helpers/_/_to_array";
var copy = _to_array(items);
use(copy);
"#;
let output = apply(input);
assert!(
output.contains("_to_array(items)") || output.contains("_(items)"),
"non-destructuring toArray call must be preserved: {output}"
);
assert!(
output.contains("@swc/helpers/_/_to_array"),
"import must be preserved while a call site remains: {output}"
);
}
#[test]
fn preserves_non_helper_to_array_lookalike() {
let input = r#"
var customToArray = makeToArray();
var [first, ...rest_items] = customToArray(items);
use(first, rest_items);
"#;
let output = apply(input);
assert!(
output.contains("customToArray(items)"),
"non-helper toArray-like call must be preserved: {output}"
);
}
#[test]
fn folds_swc_external_to_array_end_to_end() {
// Full pipeline: swc externalHelpers lowers `const [first, ...rest] = items`
// to a temp + index/slice accesses over the helper. The whole chain should
// recover, and the @swc/helpers import should be gone.
let input = r#"
import { _ as _to_array } from "@swc/helpers/_/_to_array";
var _items = _to_array(items), first = _items[0], rest_items = _items.slice(1);
use(first, rest_items);
"#;
let expected = r#"
const [first, ...rest_items] = items;
use(first, rest_items);
"#;
assert_eq_normalized(&render(input), expected);
}
#[test]
fn unwraps_maybe_array_like_to_array_on_rest_pattern() {
let input = r#"
function _maybeArrayLike(orElse, arr, i) {
if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
return arr;
}
return orElse(arr, i);
}
var [first, ...rest] = _maybeArrayLike(_toArray, items);
use(first, rest);
"#;
let expected = r#"
var [first, ...rest] = items;
use(first, rest);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn preserves_maybe_array_like_on_non_rest_pattern() {
let input = r#"
var [a, b] = _maybeArrayLike(_slicedToArray, pair, 2);
use(a, b);
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn preserves_local_maybe_array_like_parameter() {
let input = r#"
function f(_maybeArrayLike, _toArray, items) {
var [first, ...rest] = _maybeArrayLike(_toArray, items);
use(first, rest);
}
"#;
assert_eq_normalized(&apply(input), input);
}
#[test]
fn preserves_non_helper_delegate_with_array_check() {
let input = r#"
function choose(orElse, arr, i) {
if (Array.isArray(arr)) {
sideEffect(arr);
}
return orElse(arr, i);
}
var [first, ...rest] = choose(transform, items);
use(first, rest);
"#;
let expected = r#"
function choose(orElse, arr, i) {
if (Array.isArray(arr)) {
sideEffect(arr);
}
return orElse(arr, i);
}
var [first, ...rest] = choose(transform, items);
use(first, rest);
"#;
assert_eq_normalized(&apply(input), expected);
}
#[test]
fn preserves_unrelated_unused_function_when_maybe_array_like_is_present() {
let input = r#"
function unrelated() {}
function _maybeArrayLike(orElse, arr, i) {
if (arr && !Array.isArray(arr) && typeof arr.length === "number") {
return arr;
}
return orElse(arr, i);
}
var [first, ...rest] = _maybeArrayLike(_toArray, items);
use(first, rest);
"#;
let expected = r#"
function unrelated() {}
var [first, ...rest] = items;
use(first, rest);
"#;
assert_eq_normalized(&apply(input), expected);
}