crates/core/tests/un_object_rest_rule.rs

GitHub
mod common;

use common::{assert_eq_normalized, render, render_rule};
use wakaru_core::facts::{
    HelperExportFact, HelperKind, ModuleFacts, ModuleFactsMap, TypeScriptHelperExportFact,
    TypeScriptHelperKind,
};
use wakaru_core::rules::UnObjectRest;

#[test]
fn basic_object_without_properties_iife() {
    // Simplest case: IIFE with no preceding destructuring
    // Excluded keys get _prefix aliases to avoid collisions, but SmartInline
    // removes unused bindings so they appear as shorthand in final output
    let input = r#"
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["a", "b"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn with_preceding_destructuring() {
    // Preceding destructuring from same source — merge into one
    // "replace" has no preceding binding so gets _replace alias
    let input = r#"
const { to, innerRef } = props;
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["replace", "to", "innerRef"]);
use(to, innerRef, rest);
"#;
    let expected = r#"
const { replace: _replace, to, innerRef, ...rest } = props;
use(to, innerRef, rest);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_tslib_named_rest_import() {
    let input = r#"
import { __rest } from "tslib";
const a = props.a;
const rest = __rest(props, ["a"]);
use(a, rest);
"#;
    let expected = r#"
const { a, ...rest } = props;
use(a, rest);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_cross_module_ts_rest_helper_fact() {
    let mut facts = ModuleFactsMap::new();
    facts.insert(
        "helpers.js",
        ModuleFacts {
            ts_helper_exports: vec![TypeScriptHelperExportFact {
                exported: "__rest".into(),
                local: Some("__rest".into()),
                kind: TypeScriptHelperKind::Rest,
            }],
            ..Default::default()
        },
    );

    let input = r#"
import { __rest } from "./helpers.js";
var label = props.label, rest = __rest(props, ["label"]);
use(label, rest);
"#;
    let expected = r#"
import { __rest } from "./helpers.js";
var { label, ...rest } = props;
use(label, rest);
"#;
    assert_eq_normalized(
        &render_rule(input, |mark| UnObjectRest::new_with_facts(mark, &facts)),
        expected,
    );
}

#[test]
fn handles_cross_module_ts_rest_helper_namespace_fact() {
    let mut facts = ModuleFactsMap::new();
    facts.insert(
        "helpers.js",
        ModuleFacts {
            ts_helper_exports: vec![TypeScriptHelperExportFact {
                exported: "__rest".into(),
                local: Some("__rest".into()),
                kind: TypeScriptHelperKind::Rest,
            }],
            ..Default::default()
        },
    );

    let input = r#"
import * as helpers from "./helpers.js";
var label = props.label, rest = helpers.__rest(props, ["label"]);
use(label, rest);
"#;
    let expected = r#"
import * as helpers from "./helpers.js";
var { label, ...rest } = props;
use(label, rest);
"#;
    assert_eq_normalized(
        &render_rule(input, |mark| UnObjectRest::new_with_facts(mark, &facts)),
        expected,
    );
}

#[test]
fn handles_tslib_namespace_rest_require() {
    let input = r#"
var tslib_1 = require("tslib");
const a = props.a;
const rest = tslib_1.__rest(props, ["a"]);
use(a, rest);
"#;
    let expected = r#"
import tslib_1 from "tslib";
const { a, ...rest } = props;
use(a, rest);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn with_preceding_prop_access() {
    // const x = obj.prop before IIFE — absorbed into rest destructuring with alias
    let input = r#"
const x = props.a;
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["a", "b"]);
use(x, rest);
"#;
    // Test rule in isolation to verify alias handling
    let rule_output = render_rule(input, UnObjectRest::new);
    insta::assert_snapshot!("with_preceding_prop_access_rule", rule_output);

    // Full pipeline: SmartInline runs after and may inline x
    let pipeline_output = render(input);
    insta::assert_snapshot!("with_preceding_prop_access_pipeline", pipeline_output);
}

#[test]
fn plain_spreads_do_not_trigger_elided_rest_reattachment() {
    let input = r#"
var missing;
var value = {
    ...source
};
use(missing, value);
"#;
    assert_eq_normalized(&render_rule(input, UnObjectRest::new), input.trim());
}

#[test]
fn with_bare_access() {
    // props.replace; (bare access, no binding) is absorbed. The long `_replace`
    // alias stays descriptive enough, while short `_to` can collapse to shorthand.
    let input = r#"
props.replace;
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["replace", "to"]);
use(rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn multi_declarator_comma_separated() {
    // Babel output: var t = e.to, n = e.exact, d = IIFE(e, ["to","exact"]), p = expr
    let input = r#"
const f = (e) => {
    var t = e.to, n = e.exact, d = (function(e, t) {
        var n = {};
        for (var r in e) {
            t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
        }
        return n;
    })(e, ["to", "exact"]), p = "hello";
    use(t, n, d, p);
};
"#;
    let rule_output = render_rule(input, UnObjectRest::new);
    insta::assert_snapshot!(rule_output);
}

#[test]
fn with_many_keys_destructuring() {
    // NavLink-like pattern: large destructuring before IIFE with same keys
    let input = r#"
const f = (e) => {
    const { to, exact, strict } = e;
    const d = ((e, t) => {
        const n = {};
        for (const r in e) {
            t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
        }
        return n;
    })(e, ["to", "exact", "strict"]);
    use(to, exact, strict, d);
};
"#;
    let rule_output = render_rule(input, UnObjectRest::new);
    insta::assert_snapshot!(rule_output);
}

#[test]
fn with_string_key_in_destructuring() {
    // "aria-current" is a string key — should still be absorbed
    let input = r#"
const f = (e) => {
    const { to, "aria-current": ariaCurrent } = e;
    const d = ((e, t) => {
        const n = {};
        for (const r in e) {
            t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
        }
        return n;
    })(e, ["to", "aria-current"]);
    use(to, ariaCurrent, d);
};
"#;
    let rule_output = render_rule(input, UnObjectRest::new);
    insta::assert_snapshot!(rule_output);
}

#[test]
fn with_shadowed_iife_param() {
    // IIFE param shadows outer variable — should still detect
    let input = r#"
const f = (e) => {
    const { to } = e;
    const d = ((e, t) => {
        const n = {};
        for (const r in e) {
            t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
        }
        return n;
    })(e, ["to", "extra"]);
    use(to, d);
};
"#;
    let rule_output = render_rule(input, UnObjectRest::new);
    insta::assert_snapshot!(rule_output);
}

#[test]
fn no_match_arbitrary_for_in_iife() {
    // P1 regression: IIFE with for-in but no indexOf/hasOwnProperty must NOT be matched
    let input = r#"
const rest = ((e, t) => {
    const n = {};
    for (const r in e) { sideEffect(r); }
    return fallback;
})(props, ["a"]);
use(rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn no_duplicate_binding_for_excluded_key() {
    // P1 regression: excluded key with existing binding in scope must not create duplicate const
    let input = r#"
const replace = external;
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["replace"]);
use(replace, rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn function_form_helper() {
    // Function expression form (not arrow)
    let input = r#"
const rest = (function(e, t) {
    var n = {};
    for (var r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["x"]);
"#;
    let expected = r#"
const { x, ...rest } = props;
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn alias_does_not_collide_with_existing_binding() {
    // When _replace already exists in scope, the generated alias should not duplicate it
    let input = r#"
const _replace = sentinel;
const rest = function(e, t) {
    var n = {};
    for (var r in e) t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    return n;
}(props, ["replace"]);
"#;
    let result = render(input);
    insta::assert_snapshot!(result);
}

// ── Named function helper (non-IIFE) ─────────────────────────────

#[test]
fn named_owp_helper_basic() {
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const x = props.a;
const rest = m(props, ["a", "b"]);
use(x, rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_swc_external_import() {
    let input = r#"
import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
var name = app_info.name, rest_info = _object_without_properties(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
const { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_cross_module_default_object_helper_member() {
    let mut facts = ModuleFactsMap::new();
    facts.insert(
        "helpers.js",
        ModuleFacts {
            default_object_helper_exports: vec![HelperExportFact {
                exported: "_".into(),
                local: Some("rest".into()),
                kind: HelperKind::ObjectWithoutProperties,
            }],
            ..Default::default()
        },
    );

    let input = r#"
import helpers from "./helpers.js";
var name = app_info.name, rest_info = helpers._(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
import helpers from "./helpers.js";
var { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(
        &render_rule(input, |mark| UnObjectRest::new_with_facts(mark, &facts)),
        expected,
    );
}

#[test]
fn named_owp_cross_module_direct_helper_keeps_import() {
    let mut facts = ModuleFactsMap::new();
    facts.insert(
        "helpers.js",
        ModuleFacts {
            helper_exports: vec![HelperExportFact {
                exported: "rest".into(),
                local: Some("rest".into()),
                kind: HelperKind::ObjectWithoutProperties,
            }],
            ..Default::default()
        },
    );

    let input = r#"
import { rest as objectWithoutProperties } from "./helpers.js";
var name = app_info.name, rest_info = objectWithoutProperties(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
import { rest as objectWithoutProperties } from "./helpers.js";
var { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(
        &render_rule(input, |mark| UnObjectRest::new_with_facts(mark, &facts)),
        expected,
    );
}

#[test]
fn named_owp_helper_with_preceding_destructuring() {
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const { to, exact } = props;
const rest = m(props, ["to", "exact", "strict"]);
use(to, exact, rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_multiple_call_sites() {
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const rest1 = m(a, ["x"]);
const rest2 = m(b, ["y", "z"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_absorbs_default_pairs() {
    // Two-statement pattern: extraction + ternary default → destructuring with default
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const a = t;
const a_name = a.name;
const x = a_name === undefined ? "default" : a_name;
const a_value = a.value;
const y = a_value === undefined ? 42 : a_value;
const rest = m(a, ["name", "value"]);
use(x, y, rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_undefined_default_omitted() {
    // When default is `undefined`, no explicit default is needed in destructuring
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const a_prop = obj.prop;
const x = a_prop === undefined ? undefined : a_prop;
const rest = m(obj, ["prop"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn iife_absorbs_default_pairs() {
    let input = r#"
const a_name = props.name;
const x = a_name === undefined ? "default" : a_name;
const a_value = props.value;
const y = a_value === undefined ? 42 : a_value;
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["name", "value"]);
use(x, y, rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn iife_absorbs_boolean_defaults() {
    let input = r#"
const a_enabled = props.enabled;
const x = a_enabled === undefined || a_enabled;
const a_hidden = props.hidden;
const y = a_hidden !== undefined && a_hidden;
const rest = ((e, t) => {
    const n = {};
    for (const r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
})(props, ["enabled", "hidden"]);
use(x, y, rest);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_boolean_default_true() {
    // `tmp === undefined || tmp` is Babel's transpilation of `{ prop = true }`
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const a_enabled = obj.enabled;
const x = a_enabled === undefined || a_enabled;
const rest = m(obj, ["enabled"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_boolean_default_false() {
    // `tmp !== undefined && tmp` is Babel's transpilation of `{ prop = false }`
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const a_withRef = obj.withRef;
const R = a_withRef !== undefined && a_withRef;
const rest = m(obj, ["withRef"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_inside_function_body() {
    // Named helper defined at module level, called inside a function
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (!(t.indexOf(i[r]) >= 0)) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
export function foo(t = {}) {
    const a_name = t.name;
    const x = a_name === undefined ? "default" : a_name;
    const rest = m(t, ["name"]);
    use(x, rest);
}
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_decompiled_object_keys_form() {
    // Exact shape from webpack4 module-23 after Stage 1 normalization:
    // separate temp vars, key assigned in loop, copy uses temp var
    let input = r#"
function m(e, t) {
    if (e == null) {
        return {};
    }
    let n;
    let r;
    const o = {};
    const i = Object.keys(e);
    for(r = 0; r < i.length; r++){
        n = i[r];
        if (!(t.indexOf(n) >= 0)) {
            o[n] = e[n];
        }
    }
    return o;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_minified_or_guard_object_keys_form() {
    let input = r#"
function m(e, t) {
    if (e == null) {
        return {};
    }
    let n;
    let r;
    const o = {};
    const i = Object.keys(e);
    for(r = 0; r < i.length; r++){
        n = i[r];
        t.indexOf(n) >= 0 || (o[n] = e[n]);
    }
    return o;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_in_variant() {
    // The for-in + hasOwnProperty variant as a named function
    let input = r#"
function m(e, t) {
    var n = {};
    for (var r in e) {
        t.indexOf(r) >= 0 || Object.prototype.hasOwnProperty.call(e, r) && (n[r] = e[r]);
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_babel_loose_continue_form() {
    let input = r#"
function _objectWithoutPropertiesLoose(r, e) {
    if (null == r) return {};
    var t = {};
    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
        if (-1 !== e.indexOf(n)) continue;
        t[n] = r[n];
    }
    return t;
}
const { name } = app_info, rest_info = _objectWithoutPropertiesLoose(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
const { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn preserves_unrelated_object_alias_when_babel_owp_helper_fires() {
    // The recovered helper is a Babel loose form; the unused
    // Object.prototype.hasOwnProperty alias is not part of any esbuild
    // preamble and must survive the esbuild alias cleanup.
    let input = r#"
var unusedHasOwn = Object.prototype.hasOwnProperty;
function _objectWithoutPropertiesLoose(r, e) {
    if (null == r) return {};
    var t = {};
    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
        if (-1 !== e.indexOf(n)) continue;
        t[n] = r[n];
    }
    return t;
}
const { name } = app_info, rest_info = _objectWithoutPropertiesLoose(app_info, ["name"]);
use(name, rest_info);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("unusedHasOwn"),
        "unrelated Object alias must not be swept by esbuild cleanup:\n{output}"
    );
    assert!(
        output.contains("...rest_info"),
        "rest helper call should still be recovered:\n{output}"
    );
}

#[test]
fn named_owp_helper_babel_spec_wrapper_form() {
    let input = r#"
function _objectWithoutProperties(e, t) {
    if (null == e) return {};
    var o, r, i = _objectWithoutPropertiesLoose(e, t);
    if (Object.getOwnPropertySymbols) {
        var n = Object.getOwnPropertySymbols(e);
        for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
    }
    return i;
}
function _objectWithoutPropertiesLoose(r, e) {
    if (null == r) return {};
    var t = {};
    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
        if (-1 !== e.indexOf(n)) continue;
        t[n] = r[n];
    }
    return t;
}
const { name } = app_info, rest_info = _objectWithoutProperties(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
const { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_spec_wrapper_with_hoisted_exclusion_array() {
    let input = r#"
var _excluded = ["name"];
function _objectWithoutProperties(e, t) {
    if (null == e) return {};
    var o, r, i = _objectWithoutPropertiesLoose(e, t);
    if (Object.getOwnPropertySymbols) {
        var n = Object.getOwnPropertySymbols(e);
        for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
    }
    return i;
}
function _objectWithoutPropertiesLoose(r, e) {
    if (null == r) return {};
    var t = {};
    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
        if (-1 !== e.indexOf(n)) continue;
        t[n] = r[n];
    }
    return t;
}
const rest_info = _objectWithoutProperties(app_info, _excluded);
use(rest_info);
"#;
    let expected = r#"
const { name: _name, ...rest_info } = app_info;
use(rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn iife_spec_wrapper_with_hoisted_exclusion_array() {
    let input = r#"
const excluded = ["label"];
const component = (props) => {
    const label = props.label;
    const rest = ((e, t) => {
        if (e == null) return {};
        var o, r, i = ((r, e) => {
            if (r == null) return {};
            var t = {};
            for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
                if (-1 !== e.indexOf(n)) continue;
                t[n] = r[n];
            }
            return t;
        })(e, t);
        if (Object.getOwnPropertySymbols) {
            var n = Object.getOwnPropertySymbols(e);
            for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
        }
        return i;
    })(props, excluded);
    use(label, rest);
};
"#;

    let expected = r#"
const component = ({ label, ...rest }) => {
    use(label, rest);
};
"#;

    assert_eq_normalized(&render(input), expected);
}

#[test]
fn keeps_defaulted_prop_alias_used_as_jsx_tag() {
    let input = r#"
const component = (props) => {
    const asProp = props.as;
    const Tag = asProp === undefined ? "div" : asProp;
    const rest = ((e, t) => {
        if (e == null) return {};
        var o, r, i = ((r, e) => {
            if (r == null) return {};
            var t = {};
            for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
                if (-1 !== e.indexOf(n)) continue;
                t[n] = r[n];
            }
            return t;
        })(e, t);
        if (Object.getOwnPropertySymbols) {
            var n = Object.getOwnPropertySymbols(e);
            for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
        }
        return i;
    })(props, ["as"]);
    return <Tag {...rest}/>;
};
"#;

    let output = render(input);
    assert!(
        output.contains("const Tag = asProp === undefined ? \"div\" : asProp"),
        "defaulted JSX tag alias should stay intact:\n{output}"
    );
    assert!(
        output.contains("return <Tag {...rest}/>"),
        "JSX tag should stay capitalized:\n{output}"
    );
    assert!(
        output.contains("const rest ="),
        "object-rest helper should not fold when it would remove the JSX tag alias:\n{output}"
    );
}

#[test]
fn keeps_defaulted_prop_alias_used_as_create_element_tag() {
    let input = r#"
const component = (props) => {
    const asProp = props.as;
    const Tag = asProp === undefined ? "div" : asProp;
    const rest = ((e, t) => {
        if (e == null) return {};
        var o, r, i = ((r, e) => {
            if (r == null) return {};
            var t = {};
            for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
                if (-1 !== e.indexOf(n)) continue;
                t[n] = r[n];
            }
            return t;
        })(e, t);
        if (Object.getOwnPropertySymbols) {
            var n = Object.getOwnPropertySymbols(e);
            for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
        }
        return i;
    })(props, ["as"]);
    return React.createElement(Tag, rest);
};
"#;

    let output = render(input);
    assert!(
        output.contains("const Tag = asProp === undefined ? \"div\" : asProp"),
        "defaulted createElement tag alias should stay intact:\n{output}"
    );
    assert!(
        output.contains("<Tag {...rest}/>"),
        "createElement tag should keep the alias binding:\n{output}"
    );
    assert!(
        output.contains("const rest ="),
        "object-rest helper should not fold when it would remove the createElement tag alias:\n{output}"
    );
}

#[test]
fn swc_numeric_namespace_object_rest() {
    let input = r#"
const helpers = require(12345);
const picked = input.picked;
const rest = helpers._T(input, ["picked"]);
use(picked, rest);
"#;
    let expected = r#"
const { picked, ...rest } = input;
use(picked, rest);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn preserves_shadowed_numeric_require_object_rest_namespace() {
    let input = r#"
function require(id) {
    return load(id);
}
const helpers = require(12345);
const picked = input.picked;
const rest = helpers._T(input, ["picked"]);
use(picked, rest);
"#;

    let output = render(input);
    assert!(
        output.contains("helpers._T(input"),
        "shadowed numeric require namespace must not be rewritten:\n{output}"
    );
    assert!(
        !output.contains("...rest"),
        "shadowed numeric require namespace must not produce object rest:\n{output}"
    );
}

#[test]
fn named_owp_helper_preserves_destructuring_defaults() {
    let input = r#"
function _objectWithoutPropertiesLoose(r, e) {
    if (null == r) return {};
    var t = {};
    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
        if (-1 !== e.indexOf(n)) continue;
        t[n] = r[n];
    }
    return t;
}
const { name: app_name, version = fallback_version } = app_info,
  rest_info = _objectWithoutPropertiesLoose(app_info, ["name", "version"]);
use(app_name, version, rest_info);
"#;
    let expected = r#"
const { name: app_name, version = fallback_version, ...rest_info } = app_info;
use(app_name, version, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_ts_rest_helper() {
    let input = r#"
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var name = app_info.name, rest_info = __rest(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
const { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_assignment_with_preceding_assignments() {
    let input = r#"
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
let id;
let token;
let options;
id = source.id;
token = source.token;
options = __rest(source, ["id", "token"]);
use(id, token, options);
"#;
    let expected = r#"
let id;
let token;
let options;
({ id, token, ...options } = source);
use(id, token, options);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_assignment_absorbs_source_initializing_member_access() {
    let input = r#"
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
let source;
let id;
let token;
let options;
let tmp;
tmp = config != null ? config : fallback();
id = (source = tmp).id;
token = source.token;
options = __rest(source, ["id", "token"]);
use(source, id, token, options);
"#;
    let expected = r#"
let source;
let id;
let token;
let options;
source = config ?? fallback();
({ id, token, ...options } = source);
use(source, id, token, options);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_assignment_absorbs_source_initializing_member_access_in_function_body() {
    let input = r#"
var excluded = ["id", "token"];
function objectWithoutProperties(source, excluded) {
    if (source == null) return {};
    var key, index, rest = objectWithoutPropertiesLoose(source, excluded);
    if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(source);
        for (index = 0; index < symbols.length; index++)
            key = symbols[index], -1 === excluded.indexOf(key) && {}.propertyIsEnumerable.call(source, key) && (rest[key] = source[key]);
    }
    return rest;
}
function objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var rest = {};
    for (var key in source) if ({}.hasOwnProperty.call(source, key)) {
        if (-1 !== excluded.indexOf(key)) continue;
        rest[key] = source[key];
    }
    return rest;
}
const load_user = async (config) => {
    let source;
    let id;
    let token;
    let options;
    let tmp;
    tmp = config != null ? config : await load_config();
    id = (source = tmp).id;
    token = source.token;
    options = objectWithoutProperties(source, excluded);
    return fetch_user(id, token, options);
};
use(load_user);
"#;
    let expected = r#"
const load_user = async (config) => {
    let source;
    let id;
    let token;
    let options;
    source = config ?? await load_config();
    ({ id, token, ...options } = source);
    return fetch_user(id, token, options);
};
use(load_user);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_swc_rest_helper() {
    let input = r#"
function _object_without_properties(source, excluded) {
    if (source == null) return {};
    var target = {}, sourceKeys, key, i;
    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
        sourceKeys = Reflect.ownKeys(Object(source));
        for (i = 0; i < sourceKeys.length; i++) {
            key = sourceKeys[i];
            if (excluded.indexOf(key) >= 0) continue;
            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
            target[key] = source[key];
        }
        return target;
    }
    target = _object_without_properties_loose(source, excluded);
    if (Object.getOwnPropertySymbols) {
        sourceKeys = Object.getOwnPropertySymbols(source);
        for (i = 0; i < sourceKeys.length; i++) {
            key = sourceKeys[i];
            if (excluded.indexOf(key) >= 0) continue;
            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
            target[key] = source[key];
        }
    }
    return target;
}
function _object_without_properties_loose(source, excluded) {
    if (source == null) return {};
    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
    for (i = 0; i < sourceKeys.length; i++) {
        key = sourceKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
    }
    return target;
}
var name = app_info.name, rest_info = _object_without_properties(app_info, ["name"]);
use(name, rest_info);
"#;
    let expected = r#"
const { name, ...rest_info } = app_info;
use(name, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_esbuild_rest_helper() {
    let input = r#"
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __objRest = (source, exclude) => {
    var target = {};
    for (var prop in source)
        if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
            target[prop] = source[prop];
    if (source != null && __getOwnPropSymbols)
        for (var prop of __getOwnPropSymbols(source)) {
            if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
                target[prop] = source[prop];
        }
    return target;
};
const _a = app_info, { name, version = fallback_version } = _a, rest_info = __objRest(_a, ["name", "version"]);
use(name, version, rest_info);
"#;
    let expected = r#"
const _a = app_info;
const { name, version = fallback_version, ...rest_info } = _a;
use(name, version, rest_info);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_mangled_esbuild_rest_helper() {
    // Produced by esbuild ES2017 output minified with Terser compress+mangle.
    let input = r#"
var e=Object.getOwnPropertySymbols,r=Object.prototype.hasOwnProperty,o=Object.prototype.propertyIsEnumerable,t=(t,n)=>{var a={};for(var p in t)r.call(t,p)&&n.indexOf(p)<0&&(a[p]=t[p]);if(null!=t&&e)for(var p of e(t))n.indexOf(p)<0&&o.call(t,p)&&(a[p]=t[p]);return a};const n=app_info,{name:a}=n,p=t(n,["name"]);use(a,p);
"#;
    let expected = r#"
const n = app_info;
const { name, ...rest } = n;
use(name, rest);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn reattaches_terser_elided_swc_rest_binding_from_later_spread() {
    let input = r#"
function _object_without_properties(source, excluded) {
    if (source == null) return {};
    var target = {}, sourceKeys, key, i;
    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
        sourceKeys = Reflect.ownKeys(Object(source));
        for (i = 0; i < sourceKeys.length; i++)
            key = sourceKeys[i], excluded.indexOf(key) >= 0 || Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
        return target;
    }
    target = _object_without_properties_loose(source, excluded);
    if (Object.getOwnPropertySymbols)
        for (sourceKeys = Object.getOwnPropertySymbols(source), i = 0; i < sourceKeys.length; i++)
            key = sourceKeys[i], excluded.indexOf(key) >= 0 || Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
    return target;
}
function _object_without_properties_loose(source, excluded) {
    if (source == null) return {};
    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
    for (i = 0; i < sourceKeys.length; i++)
        key = sourceKeys[i], excluded.indexOf(key) >= 0 || Object.prototype.propertyIsEnumerable.call(source, key) && (target[key] = source[key]);
    return target;
}
var name = app_info.name, rest_info, out = { ..._object_without_properties(app_info, ["name"]), name };
use(out);
"#;
    let expected = r#"
const { name, ...rest_info } = app_info;
const out = { ...rest_info, name };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn reattaches_terser_elided_esbuild_rest_binding_from_later_spread() {
    let input = r#"
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __objRest = (source, exclude) => {
    var target = {};
    for (var prop in source)
        if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
            target[prop] = source[prop];
    if (source != null && __getOwnPropSymbols)
        for (var prop of __getOwnPropSymbols(source))
            if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
                target[prop] = source[prop];
    return target;
};
const _a = app_info, { name } = _a, rest_info = undefined, out = { ...__objRest(_a, ["name"]), name };
use(out);
"#;
    let expected = r#"
const _a = app_info;
const { name, ...rest_info } = _a;
const out = { ...rest_info, name };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn named_owp_helper_for_in_requires_guarded_copy() {
    let input = r#"
function m(e, t) {
    var n = {};
    for (var r in e) {
        t.indexOf(r);
        Object.prototype.hasOwnProperty.call(e, r);
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_in_rejects_unguarded_copy() {
    let input = r#"
function m(e, t) {
    var n = {};
    for (var r in e) {
        t.indexOf(r);
        Object.prototype.hasOwnProperty.call(e, r);
        n[r] = e[r];
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_requires_copy() {
    let input = r#"
function m(e, t) {
    var n = {};
    for (var r = 0; r < 1; r++) {
        t.indexOf("a");
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_rejects_unguarded_copy() {
    let input = r#"
function m(e, t) {
    var n = {};
    for (var r = 0; r < 1; r++) {
        t.indexOf(r);
        n[r] = e[r];
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_rejects_inverted_if_guard() {
    let input = r#"
function m(e, t) {
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        if (t.indexOf(i[r]) >= 0) {
            n[i[r]] = e[i[r]];
        }
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_rejects_inverted_or_guard() {
    let input = r#"
function m(e, t) {
    if (e == null) return {};
    var n = {};
    var i = Object.keys(e);
    for (var r = 0; r < i.length; r++) {
        t.indexOf(i[r]) < 0 || (n[i[r]] = e[i[r]]);
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn named_owp_helper_for_in_rejects_inverted_guarded_copy() {
    let input = r#"
function m(e, t) {
    var n = {};
    for (var r in e) {
        Object.prototype.hasOwnProperty.call(e, r) && t.indexOf(r) >= 0 && (n[r] = e[r]);
    }
    return n;
}
const rest = m(obj, ["a"]);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn preserves_unrelated_imported_define_property_helper() {
    let input = r#"
import d from "@babel/runtime/helpers/defineProperty";
import owp from "@babel/runtime/helpers/objectWithoutProperties";
var name = app_info.name, rest_info = owp(app_info, ["name"]);
use(name, rest_info);
"#;
    let output = render(input);
    assert!(
        output.contains("...rest_info"),
        "should destructure: {output}"
    );
    assert!(
        output.contains("@babel/runtime/helpers/defineProperty"),
        "unrelated defineProperty import should survive: {output}"
    );
}

#[test]
fn computed_key_uses_body_proven_coercion_helper() {
    let input = r#"
import owp from "@babel/runtime/helpers/objectWithoutProperties";
function coerce(input) {
    return typeof input === "symbol" ? input : input + "";
}
const key = getKey();
const { [key]: picked } = source;
const rest = owp(source, [key].map(coerce));
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("const { [key]: picked, ...rest } = source;"),
        "renamed body-proven helper should recover computed object rest: {output}"
    );
}

#[test]
fn computed_key_rejects_helper_name_without_provenance() {
    let input = r#"
import owp from "@babel/runtime/helpers/objectWithoutProperties";
function _toPropertyKey(input) {
    return input;
}
const key = getKey();
const { [key]: picked } = source;
const rest = owp(source, [key].map(_toPropertyKey));
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        !output.contains("...rest"),
        "a helper-like name without matching provenance must not recover: {output}"
    );
}

#[test]
fn computed_key_uses_runtime_import_path_provenance() {
    let input = r#"
import { _ as omit } from "@swc/helpers/_/_object_without_properties";
import { _ as coerce } from "@swc/helpers/_/_to_property_key";
const key = getKey();
const picked = source[key];
const rest = omit(source, [coerce(key)]);
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("const { [key]: picked, ...rest } = source;"),
        "runtime helper path should prove the renamed coercion binding: {output}"
    );
    assert!(
        !output.contains("_to_property_key"),
        "the unused pure runtime helper import should be removed: {output}"
    );
}

#[test]
fn computed_key_inline_coercion_uses_proven_typeof_helper() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
import inspect from "@babel/runtime/helpers/typeof";
const key = getKey();
const picked = source[key];
const rest = omit(source, [inspect(key) === "symbol" ? key : String(key)]);
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("const { [key]: picked, ...rest } = source;"),
        "the inline coercion should use the proven typeof binding: {output}"
    );
}

#[test]
fn computed_key_recovers_typescript_inline_coercion() {
    let input = r#"
var __rest = (this && this.__rest) || function(source, excluded) {
    var target = {};
    for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key) && excluded.indexOf(key) < 0) {
            target[key] = source[key];
        }
    }
    return target;
};
var propertyKey = getKey(), sourceAlias = source, keyAlias = propertyKey,
    picked = sourceAlias[keyAlias],
    rest = __rest(sourceAlias, [typeof keyAlias === "symbol" ? keyAlias : keyAlias + ""]);
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("var { [propertyKey]: picked, ...rest } = sourceAlias;"),
        "TypeScript's inline property-key coercion should recover: {output}"
    );
}

#[test]
fn computed_key_preserves_typescript_key_alias_with_remaining_use() {
    let input = r#"
var __rest = (this && this.__rest) || function(source, excluded) {
    var target = {};
    for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key) && excluded.indexOf(key) < 0) {
            target[key] = source[key];
        }
    }
    return target;
};
var propertyKey = getKey(), sourceAlias = source, keyAlias = propertyKey,
    picked = sourceAlias[keyAlias],
    rest = __rest(sourceAlias, [typeof keyAlias === "symbol" ? keyAlias : keyAlias + ""]);
use(picked, rest, keyAlias);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("keyAlias = propertyKey"),
        "a key alias with a remaining use must be preserved: {output}"
    );
    assert!(
        output.contains("use(picked, rest, keyAlias);"),
        "the remaining alias reference must survive: {output}"
    );
}

#[test]
fn computed_key_recovers_esbuild_rest_key_body_shape() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
const restKey = key => typeof key === "symbol" ? key : key + "";
const key = getKey();
const sourceAlias = source, { [key]: picked } = sourceAlias,
    rest = omit(sourceAlias, [restKey(key)]);
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("const { [key]: picked, ...rest } = sourceAlias;"),
        "esbuild's renamed rest-key helper should recover by body shape: {output}"
    );
}

#[test]
fn computed_key_uses_body_proven_swc_typeof_dependency() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
function inspect(value) {
    return value && typeof Symbol !== "undefined" && value.constructor === Symbol
        ? "symbol"
        : typeof value;
}
function primitive(value, hint) {
    return value;
}
function coerce(value) {
    const key = primitive(value, "string");
    return inspect(key) === "symbol" ? key : String(key);
}
const key = getKey();
const picked = source[key];
const rest = omit(source, [coerce(key)]);
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("const { [key]: picked, ...rest } = source;"),
        "SWC's renamed nested typeof helper should be proven by body: {output}"
    );
}

#[test]
fn computed_key_rejects_unproven_swc_typeof_dependency() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
function _type_of(value) {
    return "symbol";
}
function primitive(value, hint) {
    return value;
}
function _to_property_key(value) {
    const key = primitive(value, "string");
    return _type_of(key) === "symbol" ? key : String(key);
}
const key = getKey();
const picked = source[key];
const rest = omit(source, [_to_property_key(key)]);
use(picked, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        !output.contains("...rest"),
        "SWC-like names cannot substitute for nested helper provenance: {output}"
    );
}

#[test]
fn computed_key_rest_binding_stays_mutable() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
import coerce from "@babel/runtime/helpers/toPropertyKey";
var key = getKey();
var picked = source[key], rest = omit(source, [coerce(key)]);
rest = mutate(rest);
use(picked, rest);
"#;
    let output = render(input);
    assert!(
        output.contains("let { [key]: picked, ...rest } = source;"),
        "a reassigned computed rest binding must not become const: {output}"
    );
}

#[test]
fn string_key_rest_binding_stays_mutable() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
var picked = source.name, rest = omit(source, ["name"]);
rest = mutate(rest);
use(picked, rest);
"#;
    let output = render(input);
    assert!(
        output.contains("let { name: picked, ...rest } = source;"),
        "a reassigned string-key rest binding must not become const: {output}"
    );
}

#[test]
fn computed_key_pick_separated_from_rest_is_preserved() {
    // The recovered pattern performs the property read at the rest
    // declarator's position. A declarator between the pick and the rest call
    // originally evaluates after that read, so recovery would reorder it.
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
import coerce from "@babel/runtime/helpers/toPropertyKey";
var picked = source[key], other = touch(), rest = omit(source, [coerce(key)]);
use(picked, other, rest);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("omit(source"),
        "a pick separated from the rest call must not be recovered: {output}"
    );
}

#[test]
fn computed_key_alias_is_not_collapsed_across_source_write() {
    let input = r#"
import omit from "@babel/runtime/helpers/objectWithoutProperties";
import coerce from "@babel/runtime/helpers/toPropertyKey";
let key = initialKey;
const keyAlias = key;
key = otherKey();
const picked = source[keyAlias];
const rest = omit(source, [coerce(keyAlias)]);
use(picked, rest, key);
"#;
    let output = render_rule(input, UnObjectRest::new);
    assert!(
        output.contains("const { [keyAlias]: picked, ...rest } = source;"),
        "the frozen alias must remain the computed pattern key: {output}"
    );
    assert!(
        output.contains("const keyAlias = key;"),
        "the frozen alias declaration must remain: {output}"
    );
}