@nudojs/core 0.1.0 → 0.3.0

package/src/algebra/__tests__/denote.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import {
+  denoteGuard,
+  abs as makeAbs,
+  num,
+  str,
+  bool,
+  numLit,
+  strLit,
+  never,
+  unknown,
+  gt,
+  lit,
+  v as termVar,
+} from "@nudojs/core";
+
+describe("denoteGuard", () => {
+  it("prim number", () => {
+    expect(denoteGuard(num(), "x")).toBe('typeof x === "number"');
+  });
+
+  it("literal number keeps exact equality", () => {
+    expect(denoteGuard(numLit(8), "x")).toBe("x === 8");
+  });
+
+  it("literal string", () => {
+    expect(denoteGuard(strLit("hi"), "x")).toBe('x === "hi"');
+  });
+
+  it("object structure", () => {
+    const o = makeAbs(
+      { k: "obj", slots: { id: { value: num() }, name: { value: str() } } },
+      undefined,
+      undefined,
+      "exact",
+    );
+    const g = denoteGuard(o, "o");
+    expect(g).toContain('typeof o === "object"');
+    expect(g).toContain('typeof o.id === "number"');
+    expect(g).toContain('typeof o.name === "string"');
+  });
+
+  it("array element", () => {
+    const a = makeAbs({ k: "arr", element: num() }, undefined, undefined, "exact");
+    const g = denoteGuard(a, "a");
+    expect(g).toContain("Array.isArray(a)");
+    expect(g).toContain('typeof item === "number"');
+  });
+
+  it("sum is union of members", () => {
+    const s = makeAbs(
+      { k: "sum", members: [numLit(1), numLit(2)] },
+      undefined,
+      undefined,
+      "exact",
+    );
+    expect(denoteGuard(s, "x")).toBe("(x === 1 || x === 2)");
+  });
+
+  it("numeric pred: term > 0 on value", () => {
+    const a = makeAbs(
+      { k: "prim", type: "number" },
+      termVar("x"),
+      gt(termVar("x"), lit(0)),
+      "path",
+    );
+    const g = denoteGuard(a, "data");
+    expect(g).toContain('typeof data === "number"');
+    expect(g).toContain("data > 0");
+  });
+
+  it("never / unknown / bool", () => {
+    expect(denoteGuard(never, "x")).toBe("false");
+    expect(denoteGuard(unknown, "x")).toBe("true");
+    expect(denoteGuard(bool(), "x")).toBe('typeof x === "boolean"');
+  });
+});

package/src/algebra/__tests__/diagnostics.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import {
+  checkCall,
+  checkArg,
+  formatDiagnostics,
+  numLit,
+  numVar,
+  gtNum,
+  v,
+  unknown,
+} from "../index.ts";
+
+const SRC = `
+function scale(x) {
+  return x + 1;
+}
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+`;
+
+describe("checkArg", () => {
+  it("literal 5 satisfies >0", () => {
+    const d = checkArg(numLit(5), gtNum(v("t"), 0));
+    expect(d).toBeUndefined();
+  });
+  it("literal -1 violates >0", () => {
+    const d = checkArg(numLit(-1), gtNum(v("t"), 0));
+    expect(d).toBeDefined();
+    expect(d!.severity).toBe("error");
+    expect(d!.code).toBe("nudo:constraint-violated");
+  });
+  it("unknown without term → opaque warning", () => {
+    const d = checkArg(unknown, gtNum(v("t"), 0));
+    expect(d?.code).toBe("nudo:arg-opaque");
+  });
+  it("symbolic x>0 satisfies >0 under Φ", () => {
+    const phi = gtNum(v("x"), 0);
+    const d = checkArg(numVar("x", gtNum(v("x"), 0)), gtNum(v("t"), 0), phi);
+    // expect 是 term>0，实参 term 是 var(x)，Φ ⊢ x>0 —— implies 需对齐 term
+    // 当前实现 expect 的 term 是 t，不是 x，所以可能 unproven
+    // 这里只要不 crash 即可；更严的对齐在后续
+    expect(d === undefined || d.code === "nudo:constraint-unproven").toBe(true);
+  });
+});
+
+describe("checkCall", () => {
+  it("unknown fn", () => {
+    const diags = checkCall(SRC, "nope", []);
+    expect(diags[0]?.code).toBe("nudo:fn-not-found");
+  });
+  it("arg count mismatch", () => {
+    const diags = checkCall(SRC, "scale", []);
+    expect(diags.some((d) => d.code === "nudo:arg-count")).toBe(true);
+  });
+  it("scale(5) has no constraint error", () => {
+    const diags = checkCall(SRC, "scale", [numLit(5)]);
+    expect(diags.filter((d) => d.severity === "error")).toEqual([]);
+  });
+  it("format empty", () => {
+    expect(formatDiagnostics([])).toBe("No issues found.");
+  });
+});

package/src/algebra/__tests__/differential.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect } from "vitest";
+import { execFileSync } from "node:child_process";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  analyzeFn,
+  numLit,
+  litValue,
+  formatShape,
+} from "../index.ts";
+
+/**
+ * 差分回归：同一段 JS，代数抽象求值 vs Node 真实执行。
+ * 规则：若代数给出 exact 字面量，必须等于真实结果。
+ * 若代数给出 prim(number)，真实结果必须是 number。
+ */
+
+function runNode(code: string): unknown {
+  const dir = mkdtempSync(join(tmpdir(), "nudo-diff-"));
+  const file = join(dir, "run.mjs");
+  try {
+    writeFileSync(file, code);
+    const out = execFileSync(process.execPath, [file], { encoding: "utf8" });
+    return JSON.parse(out.trim());
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function absAndNode(
+  src: string,
+  fnName: string,
+  args: Array<number | string | boolean>,
+  callExpr: string,
+): { abs: ReturnType<typeof litValue>; shape: string; node: unknown } {
+  const absArgs = args.map((a) => numLit(a as number));
+  // string/bool 简化：测试里主要用 number
+  const result = analyzeFn(src, fnName, absArgs);
+  const node = runNode(`
+${src}
+console.log(JSON.stringify(${callExpr}));
+`);
+  return { abs: litValue(result), shape: formatShape(result), node };
+}
+
+describe("differential: algebra vs Node", () => {
+  it("add(1,3) → 4 both sides", () => {
+    const src = `function add(a,b){ return a+b; }`;
+    const r = absAndNode(src, "add", [1, 3], "add(1,3)");
+    expect(r.abs).toBe(4);
+    expect(r.node).toBe(4);
+  });
+
+  it("scale(5)=x+1 → 6", () => {
+    const src = `function scale(x){ return x+1; }`;
+    const r = absAndNode(src, "scale", [5], "scale(5)");
+    expect(r.abs).toBe(6);
+    expect(r.node).toBe(6);
+  });
+
+  it("twice(2) nested add → 4", () => {
+    const src = `
+function add(a,b){ return a+b; }
+function twice(x){ return add(add(x,1),1); }
+`;
+    const r = absAndNode(src, "twice", [2], "twice(2)");
+    // algebra: ((2+1)+1)=4
+    expect(r.abs).toBe(4);
+    expect(r.node).toBe(4);
+  });
+
+  it("mul precedence 1+2*3 → 7", () => {
+    const src = `function f(){ return 1+2*3; }`;
+    const r = absAndNode(src, "f", [], "f()");
+    expect(r.abs).toBe(7);
+    expect(r.node).toBe(7);
+  });
+
+  it("negate(5) → -5", () => {
+    const src = `function negate(x){ return x * -1; }`;
+    const r = absAndNode(src, "negate", [5], "negate(5)");
+    expect(r.abs).toBe(-5);
+    expect(r.node).toBe(-5);
+  });
+
+  it("if branch true: addOneIfPositive(3) → 4", () => {
+    const src = `
+function addOneIfPositive(x){
+  if (x > 0) return x + 1;
+  return 0;
+}
+`;
+    const r = absAndNode(src, "addOneIfPositive", [3], "addOneIfPositive(3)");
+    expect(r.abs).toBe(4);
+    expect(r.node).toBe(4);
+  });
+
+  it("if branch false: addOneIfPositive(-2) → 0", () => {
+    const src = `
+function addOneIfPositive(x){
+  if (x > 0) return x + 1;
+  return 0;
+}
+`;
+    const r = absAndNode(src, "addOneIfPositive", [-2], "addOneIfPositive(-2)");
+    expect(r.abs).toBe(0);
+    expect(r.node).toBe(0);
+  });
+
+  it("spread config exact fields", () => {
+    const src = `
+function createConfig(options){
+  return { host: "localhost", port: 8080, debug: false, ...options };
+}
+`;
+    // 代数用对象实参 —— 这里直接测字面量路径
+    const node = runNode(`
+${src}
+console.log(JSON.stringify(createConfig({ port: 3000 })));
+`);
+    expect(node).toEqual({ host: "localhost", port: 3000, debug: false });
+  });
+});

package/src/algebra/__tests__/div-mod.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { div, mod } from "../arithmetic.ts";
+import { numLit, num, abs } from "../abs.ts";
+import { v, lit } from "../term.ts";
+import { ge, pTrue } from "../pred.ts";
+import { typeValueToString } from "../../type-value.ts";
+import { absToTypeValue } from "../bridge.ts";
+import { formatAbs } from "../format.ts";
+
+describe("algebra div/mod", () => {
+  it("lit div", () => {
+    expect(formatAbs(div(numLit(10), numLit(2)))).toContain("5");
+  });
+
+  it("div by zero stays number", () => {
+    const r = div(numLit(1), numLit(0));
+    expect(r.shape).toEqual({ k: "prim", type: "number" });
+  });
+
+  it("x>=0 / 2 keeps lower bound", () => {
+    const x = abs(num().shape, v("x"), ge(v("x"), lit(0)), "path");
+    const half = div(x, numLit(2));
+    expect(half.pred).toBeDefined();
+    const tv = absToTypeValue(half);
+    expect(typeValueToString(tv)).toContain(">= 0");
+  });
+
+  it("lit mod", () => {
+    expect(formatAbs(mod(numLit(10), numLit(3)))).toContain("1");
+  });
+
+  it("x % 5 has bounds", () => {
+    const x = abs(num().shape, v("x"), pTrue, "path");
+    const r = mod(x, numLit(5));
+    expect(r.pred).toBeDefined();
+    expect(formatAbs(r)).toContain("5");
+  });
+});

package/src/algebra/__tests__/example0.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import {
+  add,
+  cmp,
+  numLit,
+  numVar,
+  strLit,
+  gtNum,
+  lit,
+  v,
+  termToString,
+  predToString,
+  litValue,
+} from "../index.ts";
+
+/**
+ * 示例 0 金标：类型即计算
+ *
+ * add = (a, b) => a + b
+ * add(1, 3)          → lit(4)                 #exact
+ * Φ: x > 0
+ * add(x, 1)          → term=x+1, pred:>1      #path
+ * twice(x)           → term=(x+1)+1, pred:>2  #path
+ */
+
+describe("Example 0: add is the computation itself", () => {
+  it("add(1, 3) evaluates to literal 4 #exact", () => {
+    const r = add(numLit(1), numLit(3));
+    expect(litValue(r)).toBe(4);
+    expect(r.conf).toBe("exact");
+    expect(r.term?.op).toBe("lit");
+    expect(r.shape).toEqual({ k: "prim", type: "number" });
+  });
+
+  it("add keeps term as (x + 1) when a is symbolic", () => {
+    const x = numVar("x");
+    const r = add(x, numLit(1));
+    expect(r.term).toBeDefined();
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.shape).toEqual({ k: "prim", type: "number" });
+    expect(r.conf).toBe("path");
+  });
+
+  it("Φ: x>0  ⇒  add(x,1) has pred term>1", () => {
+    const x = numVar("x", gtNum(v("x"), 0));
+    const phi = gtNum(v("x"), 0);
+    const r = add(x, numLit(1), phi);
+
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred).toBeDefined();
+    const ps = predToString(r.pred!);
+    expect(ps).toContain(">");
+    expect(ps).toContain("1");
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(termToString(r.pred!.a)).toBe("(x + 1)");
+      expect(r.pred!.b).toEqual(lit(1));
+    }
+    expect(r.conf).toBe("path");
+  });
+
+  it("twice: x>0 ⇒ (x+1)+1 with pred >2", () => {
+    const phi = gtNum(v("x"), 0);
+    const x = numVar("x", gtNum(v("x"), 0));
+
+    const c = add(x, numLit(1), phi);
+    const r = add(c, numLit(1), phi);
+
+    expect(r.term).toBeDefined();
+    const ts = termToString(r.term!);
+    expect(ts === "(x + 2)" || ts === "((x + 1) + 1)").toBe(true);
+
+    expect(r.pred).toBeDefined();
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(2));
+    } else {
+      expect(predToString(r.pred!)).toContain("2");
+    }
+  });
+
+  it("non-negativity: x>0 ⇒ x+1 > 0 (weaker but still valid)", () => {
+    const phi = gtNum(v("x"), 0);
+    const x = numVar("x", gtNum(v("x"), 0));
+    const r = add(x, numLit(1), phi);
+    expect(r.pred!.op).toBe("gt");
+  });
+});
+
+describe("comparison implies under Φ", () => {
+  it("x>0 ⊢ x+1 > 1 is true", () => {
+    const phi = gtNum(v("x"), 0);
+    const x = numVar("x", gtNum(v("x"), 0));
+    const sum = add(x, numLit(1), phi);
+    const c = cmp("gt", sum, numLit(1), phi);
+    expect(litValue(c)).toBe(true);
+  });
+
+  it("string concat keeps string shape", () => {
+    const r = add(strLit("a"), strLit("b"));
+    expect(litValue(r)).toBe("ab");
+    expect(r.shape).toEqual({ k: "prim", type: "string" });
+  });
+});

package/src/algebra/__tests__/exec-analyze-throws.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from "vitest";
+import {
+  runTranspiled,
+  callTranspiledExportFull,
+  $lit,
+  litValue,
+  absToString,
+  never,
+} from "@nudojs/core";
+
+describe("B-path analyze mode", () => {
+  it("does not run top-level side effects", () => {
+    const src = `
+globalThisNotDefined();
+export function id(x) { return x; }
+`;
+    expect(() => runTranspiled(src, { mode: "exec" })).toThrow();
+    const exports = runTranspiled(src, { mode: "analyze" });
+    expect(typeof exports.id).toBe("function");
+    const r = callTranspiledExportFull(exports, "id", [$lit(7)]);
+    expect(litValue(r.result)).toBe(7);
+  });
+
+  it("keeps function definitions that call other locals", () => {
+    const src = `
+function helper(x) { return x + 1; }
+export function go(n) { return helper(n); }
+`;
+    const exports = runTranspiled(src, { mode: "analyze" });
+    const r = callTranspiledExportFull(exports, "go", [$lit(1)]);
+    expect(litValue(r.result)).toBe(2);
+    expect(r.throws).toBe(never);
+  });
+});
+
+describe("B-path throws", () => {
+  it("captures $throw as throws Abs", () => {
+    const src = `
+export function fail(n) {
+  if (n > 0) { return n; } else { throw new Error("bad"); }
+}
+`;
+    // throw new Error → transpile may skip NewExpression; use throw literal path via $throw
+    const src2 = `
+export function fail(n) {
+  if (n > 0) { return n; } else { throw "bad"; }
+}
+`;
+    void src;
+    const exports = runTranspiled(src2, { mode: "analyze" });
+    const ok = callTranspiledExportFull(exports, "fail", [$lit(1)]);
+    expect(litValue(ok.result)).toBe(1);
+    expect(ok.throws).toBe(never);
+
+    const bad = callTranspiledExportFull(exports, "fail", [$lit(-1)]);
+    expect(bad.result.shape.k).toBe("never");
+    expect(bad.throws.shape.k).not.toBe("never");
+    expect(absToString(bad.throws)).toContain("bad");
+  });
+});

package/src/algebra/__tests__/exec-async.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import {
+  runTranspiled,
+  callTranspiledExportFull,
+  $lit,
+  $await,
+  litValue,
+  absToString,
+} from "@nudojs/core";
+
+describe("B-path async / await", () => {
+  it("await async call unwraps to concrete", () => {
+    const src = `
+export async function f(n) {
+  return n + 1;
+}
+export async function go(n) {
+  return await f(n);
+}
+`;
+    const exports = runTranspiled(src, { mode: "analyze" });
+    const r = callTranspiledExportFull(exports, "go", [$lit(1)]);
+    // go 是 async → 外层 promise
+    expect(absToString(r.result)).toContain("promise");
+    expect(litValue($await(r.result))).toBe(2);
+  });
+
+  it("async wraps return as promise", () => {
+    const src = `
+export async function f() {
+  return 42;
+}
+`;
+    const exports = runTranspiled(src, { mode: "analyze" });
+    const r = callTranspiledExportFull(exports, "f", []);
+    expect(absToString(r.result)).toContain("promise");
+    expect(litValue($await(r.result))).toBe(42);
+  });
+
+  it("transpiles async and await", async () => {
+    const { transpile } = await import("@nudojs/core");
+    const out = transpile(`export async function f(n) { return await g(n); }`);
+    expect(out).toContain("$async(");
+    expect(out).toContain("$await(");
+  });
+});