scriptc/packages/compiler/test/ffi-lowering.test.ts

import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, expect, test } from "vitest";
import { compile, deserializeModule, validateModule } from "../src/index.js";

const dirs: string[] = [];

afterEach(async () => {
  await Promise.all(dirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
});

type IrRecord = Record<string, unknown>;

function recordsOf(value: unknown, out: IrRecord[] = []): IrRecord[] {
  if (value === null || typeof value !== "object") return out;
  if (Array.isArray(value)) {
    for (const item of value) recordsOf(item, out);
    return out;
  }
  const record = value as IrRecord;
  out.push(record);
  for (const child of Object.values(record)) recordsOf(child, out);
  return out;
}

test("manifest-bound call initializers retain ffiCall IR and declaration storage", async () => {
  const dir = await mkdtemp(join(tmpdir(), "scriptc-ffi-lowering-"));
  dirs.push(dir);
  const entry = join(dir, "main.ts");
  const outDir = join(dir, ".scriptc");
  const outPath = join(outDir, "main.ir.json");
  const profilePath = join(dir, "profile.json");
  await writeFile(
    entry,
    [
      "declare function nativeNumber(value: number): number;",
      "declare function nativeBoolean(value: boolean): boolean;",
      "const moduleConst = nativeNumber(1);",
      "let moduleLet = nativeBoolean(false);",
      "var moduleVar = nativeNumber(2);",
      "function localBindings() {",
      "  const localConst = nativeNumber(3);",
      "  let localLet = nativeBoolean(true);",
      "  var localVar = nativeNumber(4);",
      "  console.log(localConst, localLet, localVar);",
      "}",
      "localBindings();",
      "",
    ].join("\n"),
  );
  await writeFile(
    profilePath,
    JSON.stringify({
      ffi_format: 1,
      functions: [
        { name: "nativeNumber", symbol: "sf_number", params: ["f64"], returns: "f64" },
        { name: "nativeBoolean", symbol: "sf_boolean", params: ["bool"], returns: "bool" },
      ],
      libraries: [],
    }),
  );

  const result = await compile(entry, {
    outDir,
    outPath,
    outputKind: "ir",
    ffiProfilePath: profilePath,
  });
  if (!result.ok) {
    throw new Error(
      result.diagnostics
        .map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`)
        .join("\n"),
    );
  }

  const module = deserializeModule(await readFile(outPath, "utf8"));
  expect(validateModule(module)).toEqual([]);

  const expectedGlobals = ["moduleConst", "moduleLet", "moduleVar"];
  const globals = module.globals ?? [];
  expect(globals.map((global) => global.name)).toEqual(expect.arrayContaining(expectedGlobals));
  const globalIds = new Set(
    globals.filter((global) => expectedGlobals.includes(global.name)).map((global) => global.id),
  );

  const localFn = module.functions.find((fn) => fn.name.endsWith("localBindings"));
  expect(localFn).toBeDefined();
  const expectedLocals = ["localConst", "localLet", "localVar"];
  const localIds = new Set(
    localFn!.locals.filter((local) => expectedLocals.includes(local.name)).map((local) => local.id),
  );
  expect(localIds.size).toBe(expectedLocals.length);

  const records = recordsOf(module);
  const ffiInitializers = (ids: ReadonlySet<string>) =>
    records.filter(
      (record) =>
        (record.kind === "assign" &&
          typeof record.localId === "string" &&
          ids.has(record.localId) &&
          (record.value as IrRecord | undefined)?.kind === "ffiCall") ||
        (record.kind === "varDecl" &&
          typeof record.localId === "string" &&
          ids.has(record.localId) &&
          (record.init as IrRecord | undefined)?.kind === "ffiCall"),
    );
  expect(ffiInitializers(globalIds)).toHaveLength(expectedGlobals.length);
  expect(ffiInitializers(localIds)).toHaveLength(expectedLocals.length);

  const ffiCalls = records.filter((record) => record.kind === "ffiCall");
  expect(ffiCalls).toHaveLength(6);
  expect(
    records.some((record) => record.kind === "libCall" && record.fn === "global.undefRead"),
  ).toBe(false);
});