crates/core/tests/un_object_spread_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::UnObjectSpread;

#[test]
fn replaces_object_spread2_with_spread_syntax() {
    let input = r#"
var _objectSpread2 = require("@babel/runtime/helpers/objectSpread2");
var x = _objectSpread2({}, y);
"#;
    let expected = r#"
const x = { ...y };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_multiple_spread_sources() {
    let input = r#"
var _objectSpread2 = require("@babel/runtime/helpers/objectSpread2");
var x = _objectSpread2({}, a, b, c);
"#;
    let expected = r#"
const x = { ...a, ...b, ...c };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_extends_helper() {
    let input = r#"
var _extends = require("@babel/runtime/helpers/extends");
var x = _extends({}, obj1, obj2);
"#;
    let expected = r#"
const x = { ...obj1, ...obj2 };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_babel_runtime_esm_import_extends() {
    let input = r#"
import _extends from "@babel/runtime/helpers/extends";
var x = _extends({}, app_info, base_info);
"#;
    let expected = r#"
const x = { ...app_info, ...base_info };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_swc_external_extends_import() {
    let input = r#"
import { _ as _extends } from "@swc/helpers/_/_extends";
var x = _extends({}, app_info, base_info);
"#;
    let expected = r#"
const x = { ...app_info, ...base_info };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_tslib_named_assign_import() {
    let input = r#"
import { __assign } from "tslib";
var x = __assign({ id: app_id }, app_info, { name: value });
"#;
    let expected = r#"
const x = { id: app_id, ...app_info, name: value };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_tslib_namespace_assign_require() {
    let input = r#"
var tslib_1 = require("tslib");
var x = tslib_1.__assign({ id: app_id }, app_info, { name: value });
"#;
    let expected = r#"
import tslib_1 from "tslib";
const x = { id: app_id, ...app_info, name: value };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_babel_runtime_esm_import_object_spread() {
    let input = r#"
import _objectSpread2 from "@babel/runtime/helpers/objectSpread2";
var x = _objectSpread2({}, app_info, { app_name: name });
"#;
    let expected = r#"
const x = { ...app_info, app_name: name };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_swc_external_object_spread_imports() {
    let input = r#"
import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
var x = _object_spread_props(_object_spread({}, app_info), { app_name: name });
"#;
    let expected = r#"
const x = { ...app_info, app_name: name };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn restores_non_empty_branch_first_in_terser_conditional_spread() {
    // SWC externalizes the object-spread helper, then Terser flips
    // `!saveOnBlur ? { value } : {}` to remove the negation. Recover the
    // readability-oriented branch order without changing evaluation count.
    let input = r#"
import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
const S = _object_spread(
    {},
    saveOnBlur ? {} : { value },
    saveOnBlur ? { value: value_1 } : {}
);
use(S);
"#;
    let expected = r#"
const S = {
    ...!saveOnBlur ? { value } : {},
    ...saveOnBlur ? { value: value_1 } : {}
};
use(S);
"#;

    assert_eq_normalized(&render_rule(input, UnObjectSpread::new_with_mark), expected);
}

#[test]
fn restores_each_terser_flipped_conditional_spread_independently() {
    let input = r#"
import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
const S = _object_spread(
    {},
    saveOnBlur ? {} : { value },
    saveOnBlur ? {} : { value: value_1 }
);
use(S);
"#;
    let expected = r#"
const S = {
    ...!saveOnBlur ? { value } : {},
    ...!saveOnBlur ? { value: value_1 } : {}
};
use(S);
"#;

    assert_eq_normalized(&render_rule(input, UnObjectSpread::new_with_mark), expected);
}

#[test]
fn conditional_spread_does_not_flip_without_empty_consequent() {
    let input = r#"
import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
const props = _object_spread({}, condition ? { enabled: true } : { enabled: false });
use(props);
"#;
    let expected = r#"
const props = {
    ...condition ? { enabled: true } : { enabled: false }
};
use(props);
"#;

    assert_eq_normalized(&render_rule(input, UnObjectSpread::new_with_mark), expected);
}

#[test]
fn conditional_spread_does_not_flip_two_empty_branches() {
    let input = r#"
import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
const props = _object_spread({}, condition ? {} : {});
use(props);
"#;
    let expected = r#"
const props = {
    ...condition ? {} : {}
};
use(props);
"#;

    assert_eq_normalized(&render_rule(input, UnObjectSpread::new_with_mark), expected);
}

#[test]
fn source_authored_conditional_spread_is_not_reoriented() {
    let input = r#"
const props = {
    ...condition ? {} : { value }
};
use(props);
"#;

    assert_eq_normalized(&render_rule(input, UnObjectSpread::new_with_mark), input);
}

#[test]
fn preserves_shadowed_require_runtime_object_spread_helper() {
    let input = r#"
function require(path) {
    return load(path);
}
var _objectSpread2 = require("@babel/runtime/helpers/objectSpread2");
var x = _objectSpread2({}, y);
use(x);
"#;

    let output = render(input);
    assert!(
        output.contains("_objectSpread2({}, y)"),
        "shadowed require helper binding must not be rewritten:\n{output}"
    );
    assert!(
        !output.contains("{ ...y }"),
        "shadowed require helper binding must not produce object spread:\n{output}"
    );
}

#[test]
fn handles_swc_numeric_namespace_object_spread() {
    let input = r#"
const Y = require(39889);
const out = Y.pi(Y.pi({}, app_info), { app_name: name });
"#;
    let expected = r#"
const out = { ...app_info, app_name: name };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn preserves_shadowed_numeric_require_object_spread_namespace() {
    let input = r#"
function require(id) {
    return load(id);
}
const Y = require(39889);
const out = Y.pi(Y.pi({}, app_info), { app_name: name });
use(out);
"#;

    let output = render(input);
    assert!(
        output.contains("Y.pi(Y.pi({}, app_info),"),
        "shadowed numeric require namespace must not be rewritten:\n{output}"
    );
    assert!(
        !output.contains("{ ...app_info, app_name: name }"),
        "shadowed numeric require namespace must not produce object spread:\n{output}"
    );
}

#[test]
fn swc_numeric_namespace_object_spread_requires_pi_export() {
    let input = r#"
const Y = require(39889);
const out = Y.notPi(Y.notPi({}, app_info), { app_name: name });
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn swc_numeric_namespace_object_spread_preserves_mutating_target() {
    let input = r#"
const Y = require(39889);
const out = Y.pi(target, app_info);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

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

    let input = r#"
import _extends from "./helpers.js";
var x = _extends({}, app_info, base_info);
"#;
    let expected = r#"
import _extends from "./helpers.js";
var x = { ...app_info, ...base_info };
"#;
    assert_eq_normalized(
        &render_rule(input, |_| UnObjectSpread::new_with_facts(&facts)),
        expected,
    );
}

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

    let input = r#"
import { Z as _extends } from "./helpers.js";
var x = _extends({}, app_info, base_info);
"#;
    let expected = r#"
import { Z as _extends } from "./helpers.js";
var x = { ...app_info, ...base_info };
"#;
    assert_eq_normalized(
        &render_rule(input, |_| UnObjectSpread::new_with_facts(&facts)),
        expected,
    );
}

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

    let input = r#"
import { __assign as assign } from "./helpers.js";
var x = assign({ id: app_id }, app_info, { name: value });
"#;
    let expected = r#"
import { __assign as assign } from "./helpers.js";
var x = { id: app_id, ...app_info, name: value };
"#;
    assert_eq_normalized(
        &render_rule(input, |_| UnObjectSpread::new_with_facts(&facts)),
        expected,
    );
}

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

    let input = r#"
import * as helpers from "./helpers.js";
var x = helpers.__assign({ id: app_id }, app_info, { name: value });
"#;
    let expected = r#"
import * as helpers from "./helpers.js";
var x = { id: app_id, ...app_info, name: value };
"#;
    assert_eq_normalized(
        &render_rule(input, |_| UnObjectSpread::new_with_facts(&facts)),
        expected,
    );
}

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

    let input = r#"
import helpers from "./helpers.js";
var x = helpers._({}, app_info, { name: value });
"#;
    let expected = r#"
import helpers from "./helpers.js";
var x = { ...app_info, name: value };
"#;
    assert_eq_normalized(
        &render_rule(input, |_| UnObjectSpread::new_with_facts(&facts)),
        expected,
    );
}

#[test]
fn handles_nested_babel_pattern() {
    // Babel generates nested _objectSpread2 calls, each with {} as first arg:
    // _objectSpread2(_objectSpread2({}, a), {}, { b: 1 })
    let input = r#"
var _objectSpread2 = require("@babel/runtime/helpers/objectSpread2");
var x = _objectSpread2({}, a, { b: 1 });
"#;
    let expected = r#"
const x = { ...a, b: 1 };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_esm_object_spread() {
    let input = r#"
var _objectSpread2 = require("@babel/runtime/helpers/esm/objectSpread2");
var x = _objectSpread2({}, y);
"#;
    let expected = r#"
const x = { ...y };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_fallback_object_spread() {
    let input = r#"
var _objectSpread = require("@babel/runtime/helpers/objectSpread");
var x = _objectSpread({}, y);
"#;
    let expected = r#"
const x = { ...y };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn preserves_non_empty_first_arg() {
    // Both _extends and _objectSpread2 mutate their first arg.
    // Non-empty first arg must be preserved.
    let input = r#"
var _objectSpread2 = require("@babel/runtime/helpers/objectSpread2");
var x = _objectSpread2(target, { a: 1 });
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn extends_preserves_non_empty_target() {
    let input = r#"
var _extends = require("@babel/runtime/helpers/extends");
var x = _extends(target, source);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn removes_helper_declaration() {
    let input = r#"
var _objectSpread2 = require("@babel/runtime/helpers/objectSpread2");
var x = _objectSpread2({}, y);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

// ---------------------------------------------------------------------------
// Body-shape detection: inlined helper forms
// ---------------------------------------------------------------------------

#[test]
fn detects_inlined_extends() {
    let input = r#"
function _extends() {
    _extends = Object.assign || function(target) {
        for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];
            for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };
    return _extends.apply(this, arguments);
}
var x = _extends({}, obj1, obj2);
"#;
    let expected = r#"
const x = { ...obj1, ...obj2 };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_babel_extends_bind_apply_null() {
    let input = r#"
function _extends() {
    return _extends = Object.assign ? Object.assign.bind() : function(n) {
        for (var e = 1; e < arguments.length; e++) {
            var t = arguments[e];
            for (var r in t) {
                ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
            }
        }
        return n;
    }, _extends.apply(null, arguments);
}
const out = _extends({}, app_info, { name: value }, base_info);
use(out);
"#;
    let expected = r#"
const out = { ...app_info, name: value, ...base_info };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_fresh_non_empty_helper_target() {
    let input = r#"
var _extends = require("@babel/runtime/helpers/extends");
var x = _extends({ id: app_id }, app_info);
"#;
    let expected = r#"
const x = { id: app_id, ...app_info };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn handles_nested_babel_object_spread_with_fresh_target() {
    let input = r#"
function _objectSpread(e) {
    for (var r = 1; r < arguments.length; r++) {
        var t = null != arguments[r] ? arguments[r] : {};
        r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
            _defineProperty(e, r, t[r]);
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
            Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
        });
    }
    return e;
}
const out = _objectSpread(_objectSpread({}, app_info), {}, { name: value }, base_info);
use(out);
"#;
    let expected = r#"
const out = { ...app_info, name: value, ...base_info };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_ts_assign_helper() {
    let input = r#"
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var out = __assign(__assign({ id: app_id }, app_info), { name: value });
use(out);
"#;
    let expected = r#"
const out = { id: app_id, ...app_info, name: value };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_swc_object_spread_helpers() {
    let input = r#"
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
    } else {
        obj[key] = value;
    }
    return obj;
}
function _object_spread(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i] != null ? arguments[i] : {};
        var ownKeys = Object.keys(source);
        if (typeof Object.getOwnPropertySymbols === "function") {
            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
            }));
        }
        ownKeys.forEach(function(key) {
            _define_property(target, key, source[key]);
        });
    }
    return target;
}
function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
    if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(object);
        if (enumerableOnly) {
            symbols = symbols.filter(function(sym) {
                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
            });
        }
        keys.push.apply(keys, symbols);
    }
    return keys;
}
function _object_spread_props(target, source) {
    source = source != null ? source : {};
    if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
        ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
    }
    return target;
}
var out = _object_spread(_object_spread_props(_object_spread({}, app_info), { name: value }), base_info);
use(out);
"#;
    let expected = r#"
const out = { ...app_info, name: value, ...base_info };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn removes_minified_babel_object_spread_helper_dependencies() {
    let input = r#"
function l(e) {
    l = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(e) {
        return typeof e;
    } : function(e) {
        return e && typeof Symbol === "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
    };
    return l(e);
}
function a(e, t) {
    var r = Object.keys(e);
    if (Object.getOwnPropertySymbols) {
        var n = Object.getOwnPropertySymbols(e);
        if (t) {
            n = n.filter(function(t) {
                return Object.getOwnPropertyDescriptor(e, t).enumerable;
            });
        }
        r.push.apply(r, n);
    }
    return r;
}
function i(e, t, r) {
    t = function(e) {
        var t = function(e) {
            if (l(e) != "object" || !e) {
                return e;
            }
            var t = e[Symbol.toPrimitive];
            if (t !== undefined) {
                var r = t.call(e, "string");
                if (l(r) != "object") {
                    return r;
                }
                throw new TypeError("@@toPrimitive must return a primitive value.");
            }
            return String(e);
        }(e);
        return l(t) == "symbol" ? t : t + "";
    }(t);
    if (t in e) {
        Object.defineProperty(e, t, {
            value: r,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        e[t] = r;
    }
    return e;
}
function o(e) {
    for (var t = 1; t < arguments.length; t++) {
        var r = arguments[t] != null ? arguments[t] : {};
        if (t % 2) {
            a(Object(r), true).forEach(function(t) {
                i(e, t, r[t]);
            });
        } else if (Object.getOwnPropertyDescriptors) {
            Object.defineProperties(e, Object.getOwnPropertyDescriptors(r));
        } else {
            a(Object(r)).forEach(function(t) {
                Object.defineProperty(e, t, Object.getOwnPropertyDescriptor(r, t));
            });
        }
    }
    return e;
}
var out = o({}, app_info, { name: value });
use(out);
"#;
    let expected = r#"
var out = { ...app_info, name: value };
use(out);
"#;

    assert_eq_normalized(&render_rule(input, |_| UnObjectSpread::new()), expected);
}

#[test]
fn preserves_dependencies_when_object_spread_helper_call_remains() {
    let input = r#"
function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
    if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(object);
        if (enumerableOnly) {
            symbols = symbols.filter(function(sym) {
                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
            });
        }
        keys.push.apply(keys, symbols);
    }
    return keys;
}
function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i] != null ? arguments[i] : {};
        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
            Object.defineProperty(target, key, {
                value: source[key],
                enumerable: true,
                configurable: true,
                writable: true
            });
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
    }
    return target;
}
var out = _objectSpread2(target, source);
use(out);
"#;

    let output = render_rule(input, |_| UnObjectSpread::new());

    assert!(
        output.contains("function ownKeys"),
        "retained object spread helper must keep ownKeys dependency:\n{output}"
    );
    assert!(
        output.contains("function _objectSpread2"),
        "untransformed object spread helper should remain:\n{output}"
    );
}

#[test]
fn detects_esbuild_object_spread_helpers() {
    let input = r#"
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
    for (var prop in b || (b = {})) if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
    if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)) {
        if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
    }
    return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
const out = __spreadValues(__spreadProps(__spreadValues({}, app_info), { name: value }), base_info);
use(out);
"#;
    let expected = r#"
const out = { ...app_info, name: value, ...base_info };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn ignores_descriptor_copy_utility_without_esbuild_values_preamble() {
    // Same shape as esbuild's __spreadProps, but with no __spreadValues alias
    // preamble this is a user descriptor-copy utility; object spread would
    // drop accessor semantics.
    let input = r#"
var __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var copyDescs = (a, b) => __defProps(a, __getOwnPropDescs(b));
use(copyDescs({}, source));
"#;
    let output = render_rule(input, UnObjectSpread::new_with_mark);
    assert_eq_normalized(&output, input);
}

#[test]
fn ignores_descriptor_copy_utility_with_alias_preamble_but_no_values_helper() {
    // Full esbuild-style alias preamble but no __spreadValues/__defNormalProp
    // helper: the two-param defineProperties shape must still be treated as a
    // user descriptor-copy utility, not __spreadProps.
    let input = r#"
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var copyDescs = (a, b) => __defProps(a, __getOwnPropDescs(b));
use(copyDescs({}, source));
"#;
    let output = render_rule(input, UnObjectSpread::new_with_mark);
    assert_eq_normalized(&output, input);
}

#[test]
fn preserves_unrelated_object_alias_when_non_esbuild_helper_fires() {
    // The recovered helper is a minified Babel _extends; the unused
    // Object.defineProperties alias is not part of any esbuild preamble and
    // must survive the esbuild alias cleanup.
    let input = r#"
var unusedDefineProps = Object.defineProperties;
function n() {
    return n = Object.assign || function(e) {
        for (var t = 1; t < arguments.length; t++) {
            var r = arguments[t];
            for (var o in r)
                Object.prototype.hasOwnProperty.call(r, o) && (e[o] = r[o]);
        }
        return e;
    }, n.apply(this, arguments);
}
var x = n({}, a, b);
use(x);
"#;
    let output = render_rule(input, UnObjectSpread::new_with_mark);
    assert!(
        output.contains("unusedDefineProps"),
        "unrelated Object alias must not be swept by esbuild cleanup:\n{output}"
    );
    assert!(
        output.contains("...a"),
        "extends helper call should still be recovered:\n{output}"
    );
}

#[test]
fn ignores_esbuild_aliases_of_shadowed_object_binding() {
    let input = r#"
const Object = fake();
var __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var copyDescs = (a, b) => __defProps(a, __getOwnPropDescs(b));
use(copyDescs({}, source));
"#;
    let output = render_rule(input, UnObjectSpread::new_with_mark);
    assert_eq_normalized(&output, input);
}

#[test]
fn detects_terser_inlined_esbuild_spread_values() {
    let input = r#"
var __defProp = Object.defineProperty;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues;
const out = ((a, b) => {
    for (var prop in b || (b = {})) __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
    if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)) __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
    return a;
})({ id: app_id }, app_info);
use(out);
"#;
    let expected = r#"
const out = { id: app_id, ...app_info };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_terser_mangled_inlined_esbuild_spread_values() {
    // Produced by esbuild ES2017 output minified with Terser compress+mangle.
    let input = r#"
var e=Object.defineProperty,r=Object.getOwnPropertySymbols,t=Object.prototype.hasOwnProperty,o=Object.prototype.propertyIsEnumerable,a=(r,t,o)=>t in r?e(r,t,{enumerable:!0,configurable:!0,writable:!0,value:o}):r[t]=o,p;const n=((e,p)=>{for(var n in p||(p={}))t.call(p,n)&&a(e,n,p[n]);if(r)for(var n of r(p))o.call(p,n)&&a(e,n,p[n]);return e})({id:app_id},app_info);use(n);
"#;
    let expected = r#"
const n = { id: app_id, ...app_info };
use(n);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_terser_inlined_esbuild_spread_props() {
    let input = r#"
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
    for (var prop in b || (b = {})) __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
    if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)) __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
    return a;
};
var __spreadProps;
const out = __spreadValues(((a, b) => __defProps(a, __getOwnPropDescs(b)))(__spreadValues({}, app_info), { name: value }), base_info);
use(out);
"#;
    let expected = r#"
const out = { ...app_info, name: value, ...base_info };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_mangled_esbuild_object_spread_helpers() {
    let input = r#"
var e = Object.defineProperty,
    r = Object.defineProperties,
    t = Object.getOwnPropertyDescriptors,
    o = Object.getOwnPropertySymbols,
    n = Object.prototype.hasOwnProperty,
    l = Object.prototype.propertyIsEnumerable,
    i = (r, t, o) => t in r ? e(r, t, { enumerable: true, configurable: true, writable: true, value: o }) : r[t] = o,
    s = (e, r) => {
        for (var t in r || (r = {})) n.call(r, t) && i(e, t, r[t]);
        if (o) for (var t of o(r)) l.call(r, t) && i(e, t, r[t]);
        return e;
    },
    c = (e, o) => r(e, t(o));
const out = c(s({}, rest), { session });
use(out);
"#;
    let expected = r#"
const out = { ...rest, session };
use(out);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_terser_mangled_esbuild_spread_values_and_props_from_matrix() {
    // Produced by esbuild ES2017 output minified with Terser compress+mangle.
    let input = r#"
var e=Object.defineProperty,r=Object.defineProperties,t=Object.getOwnPropertyDescriptors,o=Object.getOwnPropertySymbols,a=Object.prototype.hasOwnProperty,n=Object.prototype.propertyIsEnumerable,p=(r,t,o)=>t in r?e(r,t,{enumerable:!0,configurable:!0,writable:!0,value:o}):r[t]=o,b=(e,r)=>{for(var t in r||(r={}))a.call(r,t)&&p(e,t,r[t]);if(o)for(var t of o(r))n.call(r,t)&&p(e,t,r[t]);return e},c;const i=b(((e,o)=>r(e,t(o)))(b({},app_info),{name:value}),base_info);use(i);
"#;
    let expected = r#"
const i = { ...app_info, name: value, ...base_info };
use(i);
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_minified_extends() {
    let input = r#"
function n() {
    return n = Object.assign || function(e) {
        for (var t = 1; t < arguments.length; t++) {
            var r = arguments[t];
            for (var o in r)
                Object.prototype.hasOwnProperty.call(r, o) && (e[o] = r[o]);
        }
        return e;
    }, n.apply(this, arguments);
}
var x = n({}, a, b);
"#;
    let expected = r#"
const x = { ...a, ...b };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_inlined_object_spread2() {
    let input = r#"
function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = null != arguments[i] ? arguments[i] : {};
        i % 2 ? ownKeys(Object(source), !0).forEach(function(key) {
            Object.defineProperty(target, key, { value: source[key], enumerable: true, configurable: true, writable: true });
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
    }
    return target;
}
var x = _objectSpread2({}, y);
"#;
    let expected = r#"
const x = { ...y };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn detects_inline_object_spread_callee() {
    let input = r#"
var x = (function(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = null != arguments[i] ? arguments[i] : {};
        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
            target[key] = source[key];
        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
    }
    return target;
})({ cursor: pointer }, padding && { padding: padding });
"#;
    let expected = r#"
var x = { cursor: pointer, ...padding && { padding: padding } };
"#;

    assert_eq_normalized(&render_rule(input, |_| UnObjectSpread::new()), expected);
}

#[test]
fn inline_object_spread_callee_preserves_extra_target_write_side_effects() {
    let input = r#"
var x = (function(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i] != null ? arguments[i] : {};
        Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : Object.keys(source).forEach(function(key) {
            target[key] = source[key];
        });
    }
    target.extra = expensive();
    return target;
})({}, y);
"#;

    let output = render_rule(input, |_| UnObjectSpread::new());

    assert!(
        output.contains("expensive()"),
        "retained inline helper call must keep side effects:\n{output}"
    );
    assert!(
        !output.contains("var x = { ...y };"),
        "inline helper with target side effects must not be collapsed:\n{output}"
    );
}

#[test]
fn detects_var_assigned_extends() {
    let input = r#"
var _extends = function() {
    _extends = Object.assign || function(target) {
        for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];
            for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };
    return _extends.apply(this, arguments);
};
var x = _extends({}, a);
"#;
    let expected = r#"
const x = { ...a };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn inlined_extends_preserves_non_empty_target() {
    let input = r#"
function _extends() {
    _extends = Object.assign || function(target) {
        for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i];
            for (var key in source) {
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };
    return _extends.apply(this, arguments);
}
var x = _extends(target, source);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn detects_object_assign_or_polyfill_as_extends() {
    // Babel 6 / pre-evaluated form: var _extends = Object.assign || function(target) { ... }
    let input = r#"
var f = Object.assign || function(e) {
    for (var t = 1; t < arguments.length; t++) {
        var n = arguments[t];
        for (var r in n) {
            if (Object.prototype.hasOwnProperty.call(n, r)) {
                e[r] = n[r];
            }
        }
    }
    return e;
};
var x = f({}, a, { b: 1 });
"#;
    let expected = r#"
const x = { ...a, b: 1 };
"#;
    assert_eq_normalized(&render(input), expected);
}

#[test]
fn object_assign_or_polyfill_preserves_non_empty_target() {
    let input = r#"
var f = Object.assign || function(e) {
    for (var t = 1; t < arguments.length; t++) {
        var n = arguments[t];
        for (var r in n) {
            if (Object.prototype.hasOwnProperty.call(n, r)) {
                e[r] = n[r];
            }
        }
    }
    return e;
};
var x = f(target, source);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn no_false_positive_zero_param_unrelated() {
    // A zero-param function that doesn't match extends shape
    let input = r#"
function init() {
    return Object.create(null);
}
var x = init();
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn no_false_positive_descriptor_copy_utility() {
    // A 1-param function using arguments + Object.defineProperty that isn't objectSpread
    let input = r#"
function copyProps(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
        Object.defineProperty(target, "meta", { value: source, enumerable: false });
    }
    return target;
}
var x = copyProps({}, source);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}