scriptc/packages/compiler/test/native-class-descriptors.test.ts

import { spawnSync } from "node:child_process";
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { expect, test } from "vitest";
import { analyze, compile } from "../src/index.js";

function fixture(source: string) {
  const dir = mkdtempSync("/tmp/scriptc-class-descriptors-");
  const entry = join(dir, "main.js");
  writeFileSync(entry, source);
  return { dir, entry };
}

test.each([
  "Object.defineProperty(value, 'x', {value: 2, writable: false});",
  "Object.defineProperties(value, {x: {value: 2}});",
])("keeps unsafe native descriptor changes fenced: %s", (operation) => {
  const { dir, entry } = fixture(`class Value { constructor() { this.x = 1; } } const value = new Value(); ${operation}`);
  try {
    const { coverage } = analyze(entry, { dynamic: false });
    expect([...coverage.diagnostics, ...(coverage.runtimeFences ?? [])].some((d) => d.code === "SC2020" && d.message.includes("Object.define"))).toBe(true);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test("JS overrides with different return types match Node", async () => {
  const { dir, entry } = fixture(`
class Base { copy(value = 1) { return value; } }
class Child extends Base {
  /** @returns {string} */
  // @ts-expect-error JavaScript permits a different return type at runtime.
  copy(value) { console.log('child'); return String(value); }
}
const child = new Child();
console.log(child.copy(2), typeof child.copy(3));
console.log(new Base().copy());
`);
  try {
    const result = await compile(entry, { dynamic: false, outDir: dir, outPath: join(dir, "program"), sanitize: process.env["SCRIPTC_SAN"] === "1" });
    if (!result.ok) throw new Error(JSON.stringify(result.diagnostics));
    const run = spawnSync(result.binaryPath, { encoding: "utf8", timeout: 30_000 });
    const oracle = spawnSync(process.execPath, [entry], { encoding: "utf8", timeout: 30_000 });
    expect(run.error).toBeUndefined();
    expect(oracle.status).toBe(0);
    expect({ status: run.status, signal: run.signal, stdout: run.stdout, stderr: run.stderr }).toEqual({ status: oracle.status, signal: oracle.signal, stdout: oracle.stdout, stderr: oracle.stderr });
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});

test("replaced instance constructors preserve argument evaluation and match Node", async () => {
  const { dir, entry } = fixture(`
function argument() { console.log('argument'); return 2; }
class Value {
  constructor(x = 1) { this.x = x; }
  clone() { return new this.constructor(argument()); }
}
function replace(value) { value.constructor = Value; }
const value = new Value();
replace(value);
console.log(value.clone().x);
`);
  try {
    const result = await compile(entry, { dynamic: false, outDir: dir, outPath: join(dir, "program"), sanitize: process.env["SCRIPTC_SAN"] === "1" });
    if (!result.ok) throw new Error(JSON.stringify(result.diagnostics));
    const run = spawnSync(result.binaryPath, { encoding: "utf8", timeout: 30_000 });
    const oracle = spawnSync(process.execPath, [entry], { encoding: "utf8", timeout: 30_000 });
    expect(run.error).toBeUndefined();
    expect(oracle.status).toBe(0);
    expect({ status: run.status, signal: run.signal, stdout: run.stdout, stderr: run.stderr }).toEqual({ status: oracle.status, signal: oracle.signal, stdout: oracle.stdout, stderr: oracle.stderr });
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});


test("derived constructor boundaries preserve initialization and refuse repeated super", async () => {
  const { dir, entry } = fixture(`
class Base { constructor(value) { this.value = value; } }
class Before extends Base { constructor() {
// @ts-expect-error Exercise the runtime initialization guard.
this.value; super(1); } }
class Missing extends Base { constructor(flag) { if (flag) super(1); } }
class Repeated extends Base { constructor() { super(1); super(2); } }
try { new Before(); } catch (error) { console.log(error instanceof ReferenceError); }
try { new Missing(false); } catch (error) { console.log(error instanceof ReferenceError); }
try { new Repeated(); } catch (error) { console.log(error.code === 'SC2020'); }
`);
  try {
    const result = await compile(entry, { outDir: dir, outPath: join(dir, "program"), backend: "llvm", optimization: "dev" });
    if (!result.ok) throw new Error(JSON.stringify(result.diagnostics));
    const execution = spawnSync(result.binaryPath, [], { encoding: "utf8" });
    expect(execution.status).toBe(0);
    expect(execution.stdout).toBe("true\ntrue\ntrue\n");
    expect(execution.stderr).toBe("");
  } finally { rmSync(dir, { recursive: true, force: true }); }
});