@intentius/tsad-reference 1.4.0

package/src/module.ts

@@ -0,0 +1,52 @@
+import * as ts from "typescript";
+import { foldExpr, collectConsts, collectLocalFunctions, FoldRejection } from "./fold.js";
+import { findShapeViolation, type ShapeViolation } from "./subset.js";
+import { registerHelpers, registerHostSpecifiers } from "./foldable-helpers.js";
+import { EMPTY_HOST, type Host } from "./host.js";
+
+export function installHost(host: Host): void { registerHelpers(host.helpers); registerHostSpecifiers(host.ownedSpecifierPrefixes); }
+export function parse(source: string, fileName = "fixture.ts"): ts.SourceFile { return ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true); }
+export function exportInitializer(sf: ts.SourceFile, name: string, admitDefault = false): ts.Expression | undefined {
+  for (const st of sf.statements) {
+    // S-ExportDefault: `export default ⟨Expr⟩` is the export named `default`, in data-host.
+    if (name === "default" && admitDefault && ts.isExportAssignment(st) && !st.isExportEquals) return st.expression;
+    if (!ts.isVariableStatement(st) || !st.modifiers?.some((x) => x.kind === ts.SyntaxKind.ExportKeyword)) continue;
+    for (const d of st.declarationList.declarations) if (ts.isIdentifier(d.name) && d.name.text === name) return d.initializer;
+  }
+  return undefined;
+}
+/** S-CallLocal's callee set: names this file binds by S-LocalFunction or imports from a project specifier. Syntax only. */
+export function localCallees(sf: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const st of sf.statements) {
+    if (ts.isFunctionDeclaration(st) && st.name && st.body) names.add(st.name.text);
+    if (ts.isVariableStatement(st) && (st.declarationList.flags & ts.NodeFlags.Const) !== 0) {
+      for (const d of st.declarationList.declarations) {
+        if (ts.isIdentifier(d.name) && d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))) names.add(d.name.text);
+      }
+    }
+    if (ts.isImportDeclaration(st) && ts.isStringLiteral(st.moduleSpecifier) && /^\.{1,2}\//.test(st.moduleSpecifier.text) && st.importClause && !st.importClause.isTypeOnly) {
+      const c = st.importClause;
+      if (c.name) names.add(c.name.text);
+      if (c.namedBindings && ts.isNamedImports(c.namedBindings)) for (const el of c.namedBindings.elements) if (!el.isTypeOnly) names.add(el.name.text);
+    }
+  }
+  return names;
+}
+
+export function shapeOfExport(source: string, name: string, host: Host = EMPTY_HOST): ShapeViolation | undefined | "no-such-export" {
+  installHost(host); const sf = parse(source); const init = exportInitializer(sf, name, host.profile === "data-host");
+  if (!init) return "no-such-export";
+  return findShapeViolation(init, host.intrinsics, localCallees(sf));
+}
+export function foldExport(source: string, name: string, host: Host = EMPTY_HOST, externals: ReadonlyMap<string, unknown> = new Map(), fileName = "fixture.ts"): { ok: true; value: unknown } | { ok: false; rule: string; line: number; column: number; message: string } {
+  installHost(host); const sf = parse(source, fileName); const init = exportInitializer(sf, name, host.profile === "data-host");
+  if (!init) return { ok: false, rule: "S-Module", line: 1, column: 1, message: `no export named ${name}` };
+  // F-Bind at the expression level: the file's own functions are bound so a
+  // same-file call folds here the way it does in a build.
+  const consts = collectConsts(sf);
+  const bound = new Map<string, unknown>(externals);
+  for (const fn of collectLocalFunctions(sf, fileName, consts, bound)) bound.set(fn.name, fn);
+  try { return { ok: true, value: foldExpr(init, { consts, externals: bound, depth: 0 }, { intrinsics: host.intrinsics }) }; }
+  catch (e) { if (e instanceof FoldRejection) return { ok: false, rule: e.rule, line: e.line, column: e.column, message: e.message }; throw e; }
+}

package/src/no-own-execution.test.ts

@@ -0,0 +1,86 @@
+/**
+ * F-NoOwnExecution (J4). The reference parses project source and reduces it;
+ * it never runs a statement of it. Revival (#61) is the one place real code is
+ * invoked, and what it invokes is the *host's* constructors and functions,
+ * never anything the folded file wrote.
+ *
+ * Asserted by folding files whose top-level statements would be observable if
+ * they ran.
+ */
+import { describe, test, expect } from "vitest";
+import { requireHost } from "@intentius/tsad-conformance";
+import { foldProject } from "./project";
+import type { Host } from "./host";
+
+const shapes = requireHost("shapes");
+const host: Host = {
+  intrinsics: shapes.intrinsics.map((i) => ({ name: i.name, isTag: i.isTag })),
+  helpers: shapes.helpers,
+  ownedSpecifierPrefixes: shapes.ownedSpecifierPrefixes,
+  values: shapes.values,
+};
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __tsadRan: string[] | undefined;
+}
+
+describe("F-NoOwnExecution", () => {
+  test("a top-level side effect never runs, and the file folds anyway", () => {
+    globalThis.__tsadRan = [];
+    const files = new Map([
+      [
+        "sideEffects.ts",
+        `import { Bucket } from "@tsad/shapes";\n` +
+          `globalThis.__tsadRan.push("top level");\n` +
+          `export const bucket = new Bucket({ name: "b" });\n`,
+      ],
+    ]);
+    const v = foldProject(files, host).verdicts.get("sideEffects.ts");
+    // The resource folds and revives into a real instance, which means the host
+    // constructor ran...
+    expect(v?.kind).toBe("fold");
+    if (v?.kind === "fold") expect((v.exports.get("bucket") as { entityType: string }).entityType).toBe("Bucket");
+    // ...and the file's own statement did not. Non-exported statements are
+    // invisible to the gate precisely because they never execute.
+    expect(globalThis.__tsadRan).toEqual([]);
+  });
+
+  test("a side effect in a called body is rejected, not executed", () => {
+    globalThis.__tsadRan = [];
+    const files = new Map([
+      ["lib.ts", `export function helper() {\n  globalThis.__tsadRan.push("body");\n  return 1;\n}\nexport const marker = 1;\n`],
+      ["caller.ts", `import { helper } from "./lib";\nexport const n = helper();\n`],
+    ]);
+    const r = foldProject(files, host);
+    const v = r.verdicts.get("caller.ts");
+    expect(v?.kind).toBe("run");
+    // S-FnBody refuses the body rather than running it, and the forward edge
+    // then takes lib.ts with it.
+    expect(r.verdicts.get("lib.ts")?.kind).toBe("run");
+    expect(globalThis.__tsadRan).toEqual([]);
+  });
+
+  test("a host constructor is the only thing revival calls", () => {
+    const files = new Map([["a.ts", `import { Bucket } from "@tsad/shapes";\nexport const b = new Bucket({ n: 1 });\n`]]);
+    const v = foldProject(files, host).verdicts.get("a.ts");
+    expect(v?.kind).toBe("fold");
+    if (v?.kind === "fold") {
+      const b = v.exports.get("b") as { lexicon: string; props: unknown };
+      expect(b.lexicon).toBe("shapes");
+      expect(b.props).toEqual({ n: 1 });
+    }
+  });
+
+  test("with no host, a resource cannot be revived and the file falls back", () => {
+    // Correct rather than silent: a namespace holding an unrevived envelope is
+    // not a folded file. F-Val-Fate has no arm that leaves one in place.
+    const files = new Map([["a.ts", `import { Bucket } from "@tsad/shapes";\nexport const b = new Bucket({ n: 1 });\n`]]);
+    const v = foldProject(files).verdicts.get("a.ts");
+    expect(v?.kind).toBe("run");
+    if (v?.kind === "run") {
+      expect(v.rule).toBe("F-Val-Fate");
+      expect(v.reason).toContain("Bucket");
+    }
+  });
+});

package/src/prebuild.test.ts

@@ -0,0 +1,68 @@
+/** #68 — F-Prebuild and F-Count: one instance per same-file construction, shared by every reference. */
+import { describe, test, expect } from "vitest";
+import { foldProject } from "./project";
+import { requireHost } from "@intentius/tsad-conformance";
+import { referenceAdapter } from "./adapter";
+
+const hostOf = (name: string) => {
+  const h = requireHost(name);
+  return { intrinsics: h.intrinsics, helpers: h.helpers, ownedSpecifierPrefixes: h.ownedSpecifierPrefixes, values: h.values };
+};
+
+describe("F-Prebuild (#68)", () => {
+  test("every reference to a same-file construction is the one instance, exported or not", () => {
+    const files = new Map([
+      [
+        "a.ts",
+        `import { Bucket } from "@tsad/shapes";
+const base = new Bucket({ name: "base" });
+export const wrapper = { inner: base, again: base };
+export { base };`,
+      ],
+    ]);
+    const r = foldProject(files, hostOf("shapes"));
+    const v = r.verdicts.get("a.ts");
+    expect(v?.kind).toBe("fold");
+    if (v?.kind !== "fold") return;
+    const wrapper = v.exports.get("wrapper") as { inner: unknown; again: unknown };
+    expect(wrapper.inner).toBe(wrapper.again);
+    expect(v.exports.get("base")).toBe(wrapper.inner);
+  });
+  test("an exported construction re-exported under another name is still one instance", () => {
+    const files = new Map([
+      ["a.ts", `import { Bucket } from "@tsad/shapes";\nexport const a = new Bucket({ name: "a" });\nexport { a as b };`],
+    ]);
+    const v = foldProject(files, hostOf("shapes")).verdicts.get("a.ts");
+    expect(v?.kind).toBe("fold");
+    if (v?.kind === "fold") expect(v.exports.get("a")).toBe(v.exports.get("b"));
+  });
+  test("a later construction sees an earlier one, in source order", () => {
+    const files = new Map([
+      [
+        "a.ts",
+        `import { Bucket, Pair } from "@tsad/shapes";
+const left = new Bucket({ name: "l" });
+const pair = new Pair(left, "r");
+export { pair };`,
+      ],
+    ]);
+    const v = foldProject(files, hostOf("shapes")).verdicts.get("a.ts");
+    expect(v?.kind).toBe("fold");
+    if (v?.kind === "fold") {
+      const pair = v.exports.get("pair") as { left: unknown };
+      expect((pair.left as { props: { name: string } }).props.name).toBe("l");
+    }
+  });
+  test("a construction that fails is skipped, and the reference to it rejects under step 1", () => {
+    // `Missing` is not a class the host supplies, so revival cannot construct it.
+    const files = new Map([
+      ["a.ts", `import { Missing } from "@tsad/shapes";\nconst m = new Missing({});\nexport const wrapper = { m };`],
+    ]);
+    const v = foldProject(files, hostOf("shapes")).verdicts.get("a.ts");
+    expect(v?.kind).toBe("run");
+    if (v?.kind === "run") expect(v.rule).toBe("F-Eval-Ident");
+  });
+  test("the adapter reports the fixture shape", () => {
+    expect(typeof referenceAdapter.foldProject).toBe("function");
+  });
+});