crates/core/tests/facts_rule.rs

GitHub
mod common;

use swc_core::common::{sync::Lrc, FileName, Mark, SourceMap, GLOBALS};
use swc_core::ecma::parser::{lexer::Lexer, EsSyntax, Parser, StringInput, Syntax};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::visit::VisitMutWith;
use wakaru_core::facts::{
    collect_module_facts, ExportFact, ExportKind, HelperExportFact, HelperKind, ImportFact,
    ImportKind, ModuleFacts, ModuleFactsMap, TypeScriptHelperExportFact, TypeScriptHelperKind,
};
use wakaru_core::{apply_rules, RulePipelineOptions};

/// Parse source, run Stage 1+2 (up through UnEsm), then collect facts.
fn collect_facts(source: &str) -> ModuleFacts {
    GLOBALS.set(&Default::default(), || {
        let cm: Lrc<SourceMap> = Default::default();
        let fm = cm.new_source_file(
            FileName::Custom("test.js".to_string()).into(),
            source.to_string(),
        );
        let lexer = Lexer::new(
            Syntax::Es(EsSyntax {
                jsx: true,
                ..Default::default()
            }),
            Default::default(),
            StringInput::from(&*fm),
            None,
        );
        let mut parser = Parser::new_from(lexer);
        let mut module = parser.parse_module().expect("parse failed");

        let unresolved_mark = Mark::new();
        let top_level_mark = Mark::new();
        module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));

        // Run pipeline through end of Stage 2
        apply_rules(
            &mut module,
            unresolved_mark,
            RulePipelineOptions::until("UnEsm"),
        );

        collect_module_facts(&module)
    })
}

/// Helper to build an ImportFact for assertions.
fn import(local: &str, source: &str, kind: ImportKind) -> ImportFact {
    ImportFact {
        local: local.into(),
        source: source.into(),
        kind,
    }
}

/// Helper to build an ExportFact for assertions.
fn export(exported: &str, local: Option<&str>, kind: ExportKind) -> ExportFact {
    ExportFact {
        exported: exported.into(),
        local: local.map(|s| s.into()),
        kind,
    }
}

fn helper_export(exported: &str, local: Option<&str>, kind: HelperKind) -> HelperExportFact {
    HelperExportFact {
        exported: exported.into(),
        local: local.map(|s| s.into()),
        kind,
    }
}

fn ts_helper_export(
    exported: &str,
    local: Option<&str>,
    kind: TypeScriptHelperKind,
) -> TypeScriptHelperExportFact {
    TypeScriptHelperExportFact {
        exported: exported.into(),
        local: local.map(|s| s.into()),
        kind,
    }
}

#[test]
fn module_facts_map_resolves_relative_specifiers_from_importer() {
    let mut map = ModuleFactsMap::new();
    map.insert("src/value.js", ModuleFacts::default());
    map.insert("shared/helper.js", ModuleFacts::default());

    assert!(map.get_from(Some("src/index.js"), "./value.js").is_some());
    assert!(map
        .get_from(Some("src/views/page.js"), "../../shared/helper.js")
        .is_some());
    assert!(map
        .get_from(Some("src/index.js"), "../../value.js")
        .is_none());
    assert!(map.get_from(Some("index.js"), "../value.js").is_none());
    assert!(map.get("./value.js").is_none());
}

// ── Import kind detection ──────────────────────────────────────────

#[test]
fn default_import() {
    let facts = collect_facts(r#"import x from "./mod";"#);
    assert_eq!(
        facts.imports,
        vec![import("x", "./mod", ImportKind::Default),]
    );
}

#[test]
fn namespace_import() {
    let facts = collect_facts(r#"import * as ns from "./mod";"#);
    assert_eq!(
        facts.imports,
        vec![import("ns", "./mod", ImportKind::Namespace),]
    );
}

#[test]
fn named_import() {
    let facts = collect_facts(r#"import { foo } from "./mod";"#);
    assert_eq!(
        facts.imports,
        vec![import("foo", "./mod", ImportKind::Named("foo".into())),]
    );
}

#[test]
fn named_import_with_alias() {
    let facts = collect_facts(r#"import { foo as bar } from "./mod";"#);
    assert_eq!(
        facts.imports,
        vec![import("bar", "./mod", ImportKind::Named("foo".into())),]
    );
}

#[test]
fn mixed_imports() {
    let facts = collect_facts(
        r#"
import def from "./a";
import * as ns from "./b";
import { x, y as z } from "./c";
"#,
    );
    assert_eq!(
        facts.imports,
        vec![
            import("def", "./a", ImportKind::Default),
            import("ns", "./b", ImportKind::Namespace),
            import("x", "./c", ImportKind::Named("x".into())),
            import("z", "./c", ImportKind::Named("y".into())),
        ]
    );
}

// ── CJS → ESM conversion ──────────────────────────────────────────

#[test]
fn require_becomes_default_import() {
    let facts = collect_facts(r#"var x = require("./mod");"#);
    assert_eq!(
        facts.imports,
        vec![import("x", "./mod", ImportKind::Default),]
    );
}

#[test]
fn interop_require_default_becomes_default_import() {
    let facts = collect_facts(
        r#"
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _mod = _interopRequireDefault(require("./mod"));
console.log(_mod.default);
"#,
    );
    // After Stage 2: helper unwrapped + UnEsm converts to import
    assert_eq!(facts.imports.len(), 1);
    assert_eq!(facts.imports[0].kind, ImportKind::Default);
    assert_eq!(facts.imports[0].source.as_ref(), "./mod");
}

// ── Export kind detection ──────────────────────────────────────────

#[test]
fn export_default_expr() {
    let facts = collect_facts(r#"export default 42;"#);
    assert_eq!(
        facts.exports,
        vec![export("default", None, ExportKind::Default),]
    );
}

#[test]
fn export_default_function() {
    let facts = collect_facts(r#"export default function foo() {}"#);
    assert_eq!(
        facts.exports,
        vec![export("default", Some("foo"), ExportKind::Default),]
    );
}

#[test]
fn export_named_function() {
    let facts = collect_facts(r#"export function foo() {}"#);
    assert_eq!(
        facts.exports,
        vec![export("foo", Some("foo"), ExportKind::Named),]
    );
}

#[test]
fn export_named_const() {
    let facts = collect_facts(r#"export const a = 1, b = 2;"#);
    assert_eq!(
        facts.exports,
        vec![
            export("a", Some("a"), ExportKind::Named),
            export("b", Some("b"), ExportKind::Named),
        ]
    );
}

#[test]
fn export_named_class() {
    let facts = collect_facts(r#"export class Foo {}"#);
    assert_eq!(
        facts.exports,
        vec![export("Foo", Some("Foo"), ExportKind::Named),]
    );
}

#[test]
fn export_specifier_list() {
    let facts = collect_facts(
        r#"
const a = 1;
const b = 2;
export { a, b as c };
"#,
    );
    assert_eq!(
        facts.exports,
        vec![
            export("a", Some("a"), ExportKind::Named),
            export("c", Some("b"), ExportKind::Named),
        ]
    );
}

#[test]
fn export_default_via_specifier() {
    let facts = collect_facts(
        r#"
const a = 1;
export { a as default };
"#,
    );
    assert_eq!(
        facts.exports,
        vec![export("default", Some("a"), ExportKind::Default),]
    );
}

#[test]
fn source_reexport_has_no_local_binding() {
    let facts = collect_facts(r#"export { value as renamed } from "./dep.js";"#);
    assert_eq!(
        facts.exports,
        vec![export("renamed", None, ExportKind::Named),]
    );
}

// ── Helper export detection ───────────────────────────────────────

#[test]
fn async_to_generator_default_helper_export() {
    let facts = collect_facts(
        r#"
function step(gen, resolve, reject, next, throwFn, key, arg) {
    try {
        var info = gen[key](arg);
        var value = info.value;
    } catch (err) {
        reject(err);
        return;
    }
    if (info.done) {
        resolve(value);
    } else {
        Promise.resolve(value).then(next, throwFn);
    }
}
function asyncToGenerator(fn) {
    return function() {
        const self = this;
        const args = arguments;
        return new Promise((resolve, reject)=>{
            const gen = fn.apply(self, args);
            function next(value) {
                step(gen, resolve, reject, next, throwFn, "next", value);
            }
            function throwFn(value) {
                step(gen, resolve, reject, next, throwFn, "throw", value);
            }
            next(undefined);
        });
    };
}
export default asyncToGenerator;
"#,
    );
    assert_eq!(
        facts.helper_exports,
        vec![helper_export(
            "default",
            Some("asyncToGenerator"),
            HelperKind::AsyncToGenerator
        )]
    );
}

#[test]
fn babel_runtime_default_helper_export() {
    let facts = collect_facts(
        r#"
import _extends from "@babel/runtime/helpers/extends";
export default _extends;
"#,
    );
    assert_eq!(
        facts.helper_exports,
        vec![helper_export(
            "default",
            Some("_extends"),
            HelperKind::Extends
        )]
    );
}

#[test]
fn babel_runtime_named_default_helper_export() {
    let facts = collect_facts(
        r#"
import { default as _objectSpread2 } from "@babel/runtime/helpers/objectSpread2";
export { _objectSpread2 as objectSpread };
"#,
    );
    assert_eq!(
        facts.helper_exports,
        vec![helper_export(
            "objectSpread",
            Some("_objectSpread2"),
            HelperKind::ObjectSpread
        )]
    );
}

#[test]
fn exported_function_helper_fact() {
    let facts = collect_facts(
        r#"
export function Z() {
    return (Z = Object.assign ? Object.assign.bind() : 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;
    }).apply(this, arguments);
}
"#,
    );
    assert_eq!(
        facts.helper_exports,
        vec![helper_export("Z", Some("Z"), HelperKind::Extends)]
    );
}

#[test]
fn default_object_helper_exports_use_property_names_for_aliases() {
    let facts = collect_facts(
        r#"
function n(strings, raw) {
    if (!raw) {
        raw = strings.slice(0);
    }
    return Object.freeze(Object.defineProperties(strings, {
        raw: {
            value: Object.freeze(raw)
        }
    }));
}
module.exports = {
    _: n,
    _tagged_template_literal: n
};
"#,
    );
    assert_eq!(
        facts.default_object_helper_exports,
        vec![
            helper_export("_", Some("n"), HelperKind::TaggedTemplateLiteral),
            helper_export(
                "_tagged_template_literal",
                Some("n"),
                HelperKind::TaggedTemplateLiteral
            ),
        ]
    );
}

#[test]
fn default_object_helper_exports_require_proven_local_helper_shape() {
    let facts = collect_facts(
        r#"
function fake(target, source) {
    console.log("side effect");
    return null;
}
module.exports = {
    _extends: fake
};
"#,
    );
    assert!(
        facts.default_object_helper_exports.is_empty(),
        "property name alone should not prove helper semantics"
    );
}

#[test]
fn tagged_template_literal_helper_export_detects_swc_shape() {
    let facts = collect_facts(
        r#"
function Y(strings, raw) {
    if (!raw) {
        raw = strings.slice(0);
    }
    return Object.freeze(Object.defineProperties(strings, {
        raw: {
            value: Object.freeze(raw)
        }
    }));
}
export { Y as _ };
"#,
    );
    assert_eq!(
        facts.helper_exports,
        vec![helper_export(
            "_",
            Some("Y"),
            HelperKind::TaggedTemplateLiteral
        )]
    );
}

#[test]
fn regenerator_runtime_default_helper_export() {
    let facts = collect_facts(
        r#"
const runtime = require("./runtime.js")();
export default runtime;
try {
    regeneratorRuntime = runtime;
} catch (err) {
    globalThis.regeneratorRuntime = runtime;
}
"#,
    );
    assert_eq!(
        facts.helper_exports,
        vec![helper_export(
            "default",
            Some("runtime"),
            HelperKind::RegeneratorRuntime
        )]
    );
}

#[test]
fn exported_typescript_awaiter_helper_fact() {
    let facts = collect_facts(
        r#"
export var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function(resolve) {
        resolve(generator.apply(thisArg, _arguments || []).next());
    });
};
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "__awaiter",
            Some("__awaiter"),
            TypeScriptHelperKind::Awaiter
        )]
    );
}

#[test]
fn exported_typescript_helper_fact_requires_inline_shape() {
    let facts = collect_facts(
        r#"
var __assign = (this && this.__assign) || customAssign;
export { __assign };
"#,
    );
    assert!(
        facts.ts_helper_exports.is_empty(),
        "name-only inline helper candidates must not become proven facts: {facts}"
    );
}

#[test]
fn exported_typescript_spread_array_alias_helper_fact() {
    let facts = collect_facts(
        r#"
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    return to.concat(from);
};
export { __spreadArray as spreadArray };
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "spreadArray",
            Some("__spreadArray"),
            TypeScriptHelperKind::SpreadArray
        )]
    );
}

#[test]
fn exported_typescript_public_function_helper_fact() {
    let facts = collect_facts(
        r#"
function helper(source, excluded) {
    var target = {};
    for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key) && excluded.indexOf(key) < 0) {
            target[key] = source[key];
        }
    }
    if (source != null && typeof Object.getOwnPropertySymbols === "function") {
        for (var i = 0, key = Object.getOwnPropertySymbols(source); i < key.length; i++) {
            if (excluded.indexOf(key[i]) < 0 && Object.prototype.propertyIsEnumerable.call(source, key[i])) {
                target[key[i]] = source[key[i]];
            }
        }
    }
    return target;
}
export { helper as __rest };
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "__rest",
            Some("helper"),
            TypeScriptHelperKind::Rest
        )]
    );
}

#[test]
fn exported_typescript_public_function_helper_fact_requires_shape() {
    let facts = collect_facts(
        r#"
export function __rest(source, excluded) {
    return customRest(source, excluded);
}
"#,
    );
    assert!(
        facts.ts_helper_exports.is_empty(),
        "public helper names without matching helper bodies must not become proven facts: {facts}"
    );
}

#[test]
fn registered_typescript_values_helper_fact() {
    let facts = collect_facts(
        r#"
function __values(o) {
  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
  if (m) return m.call(o);
  if (o && typeof o.length === "number") return {
    next: function() {
      if (o && i >= o.length) o = void 0;
      return { value: o && o[i++], done: !o };
    }
  };
  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function register(name, value) {
  exports[name] = value;
}
register("__values", __values);
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "__values",
            Some("__values"),
            TypeScriptHelperKind::Values
        )]
    );
}

#[test]
fn registered_nested_typescript_values_helper_fact() {
    let facts = collect_facts(
        r#"
export function tslibModule() {
  function register(name, value) {
    exports[name] = value;
  }
  function __values(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
      next: function() {
        if (o && i >= o.length) o = void 0;
        return { value: o && o[i++], done: !o };
      }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  register("__values", __values);
  return exports;
}
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "__values",
            Some("__values"),
            TypeScriptHelperKind::Values
        )]
    );
}

#[test]
fn registered_assigned_typescript_values_helper_fact() {
    let facts = collect_facts(
        r#"
export function tslibModule() {
  let q;
  q = (name, value) => {
    module.exports[name] = value;
  };
  let ZM8;
  ZM8 = (o) => {
    const s = typeof Symbol === "function" && Symbol.iterator;
    const m = s && o[s];
    let i = 0;
    if (m) {
      return m.call(o);
    }
    if (o && typeof o.length === "number") {
      return {
        next() {
          if (o && i >= o.length) {
            o = undefined;
          }
          return {
            value: o && o[i++],
            done: !o
          };
        }
      };
    }
    throw TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  };
  q("__values", ZM8);
  return exports;
}
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "__values",
            Some("ZM8"),
            TypeScriptHelperKind::Values
        )]
    );
    assert_eq!(
        facts.ts_helper_namespace_factory_exports,
        vec!["tslibModule"]
    );
}

#[test]
fn minified_async_helpers_prove_namespace_factory_fact() {
    let facts = collect_facts(
        r#"
export function helperFactory() {
  const exportsObject = {};
  const module = { exports: exportsObject };
  let m2q = (thisArg, args, PromiseImpl, generator) => {
    return new (PromiseImpl || (PromiseImpl = Promise))((resolve, reject) => {
      function step(result) {
        if (result.done) resolve(result.value);
        else Promise.resolve(result.value).then(fulfilled, rejected);
      }
      function fulfilled(value) { step(generator.next(value)); }
      function rejected(error) { step(generator.throw(error)); }
      step((generator = generator.apply(thisArg, args || [])).next());
    });
  };
  let p2q = (thisArg, body) => {
    const state = { label: 0, trys: [], ops: [] };
    return state;
  };
  function register(name, value) {
    module.exports[name] = value;
  }
  register("__awaiter", m2q);
  register("__generator", p2q);
  return module.exports;
}
"#,
    );

    assert!(facts.ts_helper_exports.iter().any(|helper| {
        helper.exported.as_ref() == "__awaiter" && helper.kind == TypeScriptHelperKind::Awaiter
    }));
    assert!(facts.ts_helper_exports.iter().any(|helper| {
        helper.exported.as_ref() == "__generator" && helper.kind == TypeScriptHelperKind::Generator
    }));
    assert_eq!(
        facts.ts_helper_namespace_factory_exports,
        vec!["helperFactory"]
    );
}

#[test]
fn registered_typescript_values_helper_fact_from_umd_registrar_factory() {
    let facts = collect_facts(
        r#"
(function(callback) {
  const globalTarget = {};
  const moduleExports = {};
  function makeRegistrar(target, adapter) {
    return (name, value) => target[name] = adapter ? adapter(name, value) : value;
  }
  callback(makeRegistrar(globalTarget, makeRegistrar(moduleExports)));
})((register) => {
  let ZM8;
  ZM8 = (o) => {
    const s = typeof Symbol === "function" && Symbol.iterator;
    const m = s && o[s];
    let i = 0;
    if (m) {
      return m.call(o);
    }
    if (o && typeof o.length === "number") {
      return {
        next() {
          if (o && i >= o.length) {
            o = undefined;
          }
          return {
            value: o && o[i++],
            done: !o
          };
        }
      };
    }
    throw TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  };
  register("__values", ZM8);
});
"#,
    );
    assert_eq!(
        facts.ts_helper_exports,
        vec![ts_helper_export(
            "__values",
            Some("ZM8"),
            TypeScriptHelperKind::Values
        )]
    );
}

#[test]
fn registered_typescript_values_helper_fact_ignores_nested_uninvoked_callback() {
    let facts = collect_facts(
        r#"
(function(callback) {
  function later() {
    callback((name, value) => exports[name] = value);
  }
})((register) => {
  function __values(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
      next: function() {
        if (o && i >= o.length) o = void 0;
        return { value: o && o[i++], done: !o };
      }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  register("__values", __values);
});
"#,
    );
    assert!(
        facts.ts_helper_exports.is_empty(),
        "registrars passed only inside nested functions must not become helper facts: {facts}"
    );
}

#[test]
fn registered_typescript_values_helper_fact_requires_factory_adapter_to_return_value() {
    let facts = collect_facts(
        r#"
(function(callback) {
  const globalTarget = {};
  function makeRegistrar(target, adapter) {
    return (name, value) => target[name] = adapter ? adapter(name, value) : value;
  }
  callback(makeRegistrar(globalTarget, (name, value) => null));
})((register) => {
  function __values(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
      next: function() {
        if (o && i >= o.length) o = void 0;
        return { value: o && o[i++], done: !o };
      }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  register("__values", __values);
});
"#,
    );
    assert!(
        facts.ts_helper_exports.is_empty(),
        "factory adapters that do not return the registered value must not become helper facts: {facts}"
    );
}

#[test]
fn registered_typescript_values_helper_fact_requires_inline_factory_adapter_to_return_value() {
    let facts = collect_facts(
        r#"
(function(callback) {
  const globalTarget = {};
  callback(((target, adapter) =>
    (name, value) => target[name] = adapter ? adapter(name, value) : value
  )(globalTarget, (name, value) => null));
})((register) => {
  function __values(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
      next: function() {
        if (o && i >= o.length) o = void 0;
        return { value: o && o[i++], done: !o };
      }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
  }
  register("__values", __values);
});
"#,
    );
    assert!(
        facts.ts_helper_exports.is_empty(),
        "inline factory adapters that do not return the registered value must not become helper facts: {facts}"
    );
}

#[test]
fn registered_typescript_values_helper_fact_requires_export_registrar() {
    let facts = collect_facts(
        r#"
function __values(o) {
  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
  if (m) return m.call(o);
  if (o && typeof o.length === "number") return {
    next: function() {
      if (o && i >= o.length) o = void 0;
      return { value: o && o[i++], done: !o };
    }
  };
  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function customValues(items) {
  return { next: function() { return { done: true }; } };
}
function unrelatedFactory() {
  return { __values: customValues };
}
logMetric("__values", __values);
export { unrelatedFactory };
"#,
    );
    assert!(
        facts.ts_helper_exports.is_empty(),
        "calls that do not write to exports must not register helper facts: {facts}"
    );
}

// ── CJS exports → ESM ──────────────────────────────────────────────

#[test]
fn module_exports_becomes_default_export() {
    let facts = collect_facts(r#"module.exports = { foo: 1 };"#);
    assert!(!facts.exports.is_empty());
    assert!(
        facts.exports.iter().any(|e| e.kind == ExportKind::Default),
        "should have a default export, got: {facts}"
    );
}

#[test]
fn exports_dot_name_becomes_named_export() {
    let facts = collect_facts(
        r#"
exports.foo = function() {};
exports.bar = 42;
"#,
    );
    assert!(
        facts
            .exports
            .iter()
            .any(|e| e.exported.as_ref() == "foo" && e.kind == ExportKind::Named),
        "should have named export 'foo', got: {facts}"
    );
    assert!(
        facts
            .exports
            .iter()
            .any(|e| e.exported.as_ref() == "bar" && e.kind == ExportKind::Named),
        "should have named export 'bar', got: {facts}"
    );
}

// ── No imports or exports ──────────────────────────────────────────

#[test]
fn plain_code_has_empty_facts() {
    let facts = collect_facts(r#"console.log("hello");"#);
    assert!(facts.imports.is_empty());
    assert!(facts.exports.is_empty());
}

// ── Display ────────────────────────────────────────────────────────

#[test]
fn display_formatting() {
    let facts = collect_facts(
        r#"
import x from "./a";
import { foo as bar } from "./b";
export const val = 1;
export default 42;
"#,
    );
    let display = format!("{facts}");
    assert!(
        display.contains("import x from \"./a\" [default]"),
        "got: {display}"
    );
    assert!(
        display.contains("import bar from \"./b\" [named(foo)]"),
        "got: {display}"
    );
    assert!(display.contains("export val [named]"), "got: {display}");
    assert!(
        display.contains("export default [default]"),
        "got: {display}"
    );
}

// ── Side-effect-only import ────────────────────────────────────────

#[test]
fn side_effect_import_produces_no_bindings() {
    let facts = collect_facts(r#"import "./side-effect";"#);
    // No specifiers → no import facts
    assert!(facts.imports.is_empty());
}

#[test]
fn is_helper_module_true_for_mapped_helper_export() {
    let facts = collect_facts(
        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);
}
export default _extends;
"#,
    );
    assert!(!facts.helper_exports.is_empty());
    assert!(facts.is_helper_module);
}

#[test]
fn is_helper_module_true_for_unmapped_helper_dependency() {
    // `_defineProperty` is a recognized transpiler helper but maps to no rewrite
    // HelperKind, so it never appears in `helper_exports`. It must still be
    // flagged as a helper module so dead-module elimination can treat it as
    // removable boilerplate.
    let facts = collect_facts(
        r#"
function _defineProperty(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;
}
export default _defineProperty;
"#,
    );
    assert!(
        facts.helper_exports.is_empty(),
        "defineProperty has no rewrite-mapped helper export"
    );
    assert!(
        facts.is_helper_module,
        "defineProperty should still be recognized as a helper module"
    );
}

#[test]
fn is_helper_module_false_for_plain_module() {
    let facts = collect_facts(r#"export const value = compute();"#);
    assert!(!facts.is_helper_module);
}