scriptc/tests/harness/self-hosting-emitter-inputs.ts

import {
  BOOL, F64, STRING, UNDEFINED_T, VOID, arrayOf, mapOf,
  type IrClassDef, type IrExpr, type IrFunction, type IrModule, type IrStmt, type IrType,
} from "../../packages/compiler/src/ir/ir.js";
import { boolLit, numLit, strLit, varRef } from "../../packages/compiler/src/ir/build.js";
import { IR_VERSION } from "../../packages/compiler/src/ir/serialize.js";

export interface EmitterInputCase {
  name: string;
  module: IrModule;
  sources: { file: string; text: string }[];
}

const loc = { file: "native emitter/日本.ts", start: 0, end: 1 };
const record = (shapeId: string): IrType => ({ kind: "record", shapeId });
const object = (className: string): IrType => ({ kind: "object", className });
const union = (unionId: string): IrType => ({ kind: "union", unionId });

function module(): IrModule {
  return {
    irVersion: IR_VERSION, sourceFile: loc.file, entry: "main",
    functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [], loc }],
  };
}

function effect(expr: IrExpr): IrStmt {
  return { kind: "exprStmt", expr, loc: expr.loc };
}

function method(cls: string, member: string): IrFunction {
  return {
    name: `%${cls}.${member}`,
    params: [{ localId: "this", name: "this", type: object(cls) }],
    locals: [{ id: "this", name: "this", type: object(cls), mutable: false }],
    returnType: VOID, body: [], loc,
  };
}

/** Small, hand-built inputs cover code-generation branches that ordinary
 * TypeScript sources cannot request independently (unused layouts, exact
 * library ABI metadata, module compression and literal interning). The
 * execution cases in the harness separately check emitted program behavior. */
export function emitterInputCases(): EmitterInputCase[] {
  const cases: EmitterInputCase[] = [];
  const add = (name: string, mod: IrModule, sources: EmitterInputCase["sources"] = []): EmitterInputCase => {
    const item = { name, module: mod, sources };
    cases.push(item);
    return item;
  };
  add("empty executable", module());

  const strings = module();
  strings.functions[0]!.body = [
    effect(strLit("quote\" slash\\ newline\n tab\t nul\u0000 end", loc)),
    effect(strLit("日本 π 😀 \ud800", loc)),
    effect(strLit("trigraph??/comment*/", loc)),
    effect(strLit("repeat", loc)),
    effect(strLit("repeat", loc)),
  ];
  add("literal escaping and interning", strings);

  const numbers = module();
  numbers.functions[0]!.body = [-0, 0, 1, -1, Number.MAX_VALUE, Number.MIN_VALUE, Infinity, -Infinity]
    .map((value) => effect(numLit(value, loc)));
  numbers.functions[0]!.body.push(effect({ kind: "bin", op: "/", left: numLit(0, loc), right: numLit(0, loc), type: F64, loc }));
  add("floating point constants", numbers);

  const source = module();
  source.functions[0]!.body = [effect(strLit("line two", { ...loc, start: 12, end: 20 }))];
  add("source locations with multibyte text", source, [
    { file: loc.file, text: "// 日本\nconsole.log('line two');\n" },
  ]);

  const records = module();
  records.records = [
    { id: "scalar", fields: [{ name: "flag", type: BOOL }, { name: "value", type: F64 }] },
    { id: "references", fields: [
      { name: "list", type: arrayOf(STRING) },
      { name: "text", type: STRING },
    ] },
    { id: "tuple", tuple: true, fields: [{ name: "0", type: STRING }, { name: "1", type: F64 }] },
  ];
  add("scalar, reference and tuple layouts", records);

  const recursive = module();
  recursive.records = [
    { id: "node", fields: [{ name: "children", type: arrayOf(record("node")) }, { name: "text", type: STRING }] },
  ];
  add("recursive record trace and teardown", recursive);

  const mutual = module();
  mutual.records = [
    { id: "left", fields: [{ name: "next", type: union("rightMaybe") }] },
    { id: "right", fields: [{ name: "next", type: union("leftMaybe") }] },
  ];
  mutual.unions = [
    { id: "rightMaybe", arms: [record("right"), UNDEFINED_T] },
    { id: "leftMaybe", arms: [record("left"), UNDEFINED_T] },
  ];
  add("mutually recursive optional records", mutual);

  const overflow = module();
  overflow.records = [{ id: "dictionary", fields: [{ name: "label", type: STRING }], indexValue: record("dictionary") }];
  add("recursive overflow maps", overflow);

  const cls = (name: string, base?: string): IrClassDef => ({
    name, ...(base === undefined ? {} : { base }),
    fields: [{ name: "label", type: STRING }], methods: ["visit"], loc,
  });
  const classes = module();
  classes.classes = [cls("Root"), cls("Left", "Root"), cls("Right", "Root"), cls("Leaf", "Left")];
  for (const c of classes.classes) classes.functions.push(method(c.name, "visit"));
  add("class forest and virtual dispatch tables", classes);

  const abstract = module();
  abstract.classes = [
    { ...cls("Abstract"), abstract: true, abstractMethods: ["visit"] },
    cls("Concrete", "Abstract"),
  ];
  abstract.functions.push(method("Concrete", "visit"));
  add("abstract method ABI from descendant", abstract);

  const globals = module();
  globals.globals = [
    { id: "%g.text", name: "text", type: STRING, mutable: true },
    { id: "%g.values", name: "values", type: arrayOf(F64), mutable: true },
  ];
  globals.functions[0]!.body = [
    { kind: "assign", localId: "%g.text", value: strLit("global", loc), loc },
    { kind: "assign", localId: "%g.values", value: { kind: "arrayLit", elems: [numLit(1, loc)], type: arrayOf(F64), loc }, loc },
  ];
  add("global initialization and shutdown ownership", globals);

  const constantTable = module();
  constantTable.globals = [{ id: "%g.table", name: "table", type: arrayOf(F64), mutable: false }];
  constantTable.functions[0]!.body = [
    { kind: "assign", localId: "%g.table", value: { kind: "arrayLit", elems: [1, 4, 9, 16].map((n) => numLit(n, loc)), type: arrayOf(F64), loc }, loc },
    effect({ kind: "arrayGet", arr: varRef("%g.table", arrayOf(F64), loc), index: numLit(2, loc), type: F64, loc }),
  ];
  add("constant numeric array storage", constantTable);

  const labels = module();
  labels.functions[0]!.body = [{
    kind: "block", labels: ["outer"], body: [{
      kind: "switch", disc: boolLit(true, loc), labels: ["choose"], cases: [
        { test: boolLit(false, loc), body: [effect(strLit("skipped", loc))] },
        { test: null, body: [{ kind: "break", label: "outer", loc }] },
      ], loc,
    }], loc,
  }];
  add("switch and block jump labels", labels);

  const closure = module();
  const closureType: IrType = { kind: "func", params: [], ret: STRING };
  closure.functions.push({
    name: "reader", params: [], locals: [{ id: "message", name: "message", type: STRING, mutable: true, boxed: true }], returnType: STRING,
    captures: [{ localId: "message", name: "message", type: STRING }],
    body: [{ kind: "return", value: varRef("message", STRING, loc), loc }], loc,
  });
  closure.functions[0]!.locals = [{ id: "message", name: "message", type: STRING, mutable: true, boxed: true }];
  closure.functions[0]!.body = [
    { kind: "varDecl", localId: "message", init: strLit("capture", loc), loc },
    effect({ kind: "closure", fnName: "reader", captures: ["message"], type: closureType, loc }),
  ];
  add("closure capture boxes", closure);

  const unions = module();
  unions.unions = [{ id: "scalar", arms: [BOOL, F64, STRING, UNDEFINED_T] }];
  unions.functions[0]!.body = [
    effect({ kind: "unionWrap", unionId: "scalar", tag: 2, value: strLit("payload", loc), type: union("scalar"), loc }),
    effect({ kind: "unionWrap", unionId: "scalar", tag: 3, value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: union("scalar"), loc }),
  ];
  add("union scalar payloads and immortal units", unions);

  const dictionary = module();
  const mapType = mapOf(STRING, F64);
  dictionary.functions[0]!.body = [effect({ kind: "mapNew", type: mapType, loc })];
  add("typed map construction", dictionary);

  const shortNpm = module();
  shortNpm.embedded = {
    modules: [
      { key: "/node_modules/tiny/index.js", format: "esm", source: "export const n = 1;" },
      { key: "/node_modules/tiny/config.json", format: "json", source: '{"name":"π"}' },
      { key: "/node_modules/tiny/empty.js", format: "cjs", source: "", esm: "export default {};" },
    ],
    edges: [
      { from: "/node_modules/tiny/index.js", specifier: "./config.json", to: "/node_modules/tiny/config.json", kind: "import" },
      { from: "/node_modules/tiny/index.js", specifier: "node:path", to: "node:path", kind: "any" },
    ],
  };
  add("uncompressed npm, JSON and CJS facade tables", shortNpm);

  const compressed = module();
  compressed.embedded = {
    modules: [{ key: "/node_modules/large/index.js", format: "cjs", source: "exports.value = 'repeat π';\n".repeat(2000), esm: "export const value = 'repeat π';\n".repeat(2000) }],
    edges: [
      { from: "/app/main.js", specifier: "large", to: "/node_modules/large/index.js", kind: "require" },
      { from: "/app/main.js", specifier: "large", to: "/node_modules/large/index.js", kind: "import" },
    ],
  };
  add("level-nine module and facade compression", compressed);

  const chunked = module();
  // A deterministic byte distribution prevents this source from being a
  // single repeated run while forcing several source-literal chunks.
  let state = 1;
  let text = "";
  for (let i = 0; i < 12_000; i++) {
    state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
    text += String.fromCharCode(32 + (state % 95));
  }
  chunked.embedded = { modules: [{ key: "/node_modules/random/data.json", format: "json", source: JSON.stringify(text) }], edges: [] };
  add("large source literal chunk boundaries", chunked);

  const library = module();
  library.lib = {
    profileName: "native-test", prefix: "native_", initSymbol: "native_init",
    sinkRegisterSymbol: "native_sink", collectSymbol: "native_collect", resultResetSymbol: "native_reset",
    threadInstances: false, exports: [], trapOverlays: [],
    identity: { buildIdSymbol: "native_build_id", abiVersionSymbol: "native_abi", buildId: "0123456789abcdef", abiVersion: 7 },
  };
  add("library entry points and identity constants", library);

  const threaded = module();
  threaded.lib = { ...library.lib, threadInstances: true };
  threaded.globals = [{ id: "%g.counter", name: "counter", type: F64, mutable: true }];
  threaded.functions[0]!.body = [{ kind: "assign", localId: "%g.counter", value: numLit(0, loc), loc }];
  add("thread-local library globals", threaded);
  return cases;
}