@nudojs/core 0.2.0 → 0.3.0

package/src/algebra/__tests__/ast-eval.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "vitest";
+import {
+  analyzeFn,
+  numLit,
+  numVar,
+  gtNum,
+  geNum,
+  v,
+  lit,
+  termToString,
+  predToString,
+  litValue,
+  leakIfNeeded,
+  maybeLeak,
+  exceedsBudget,
+  termDepth,
+  termNodes,
+  app,
+  resetLeakCounter,
+  mul,
+  add,
+} from "../index.ts";
+
+describe("AST eval: source → Abs", () => {
+  it("add(1,3) from real source → 4", () => {
+    const src = `
+      const add = (a, b) => a + b;
+      function main() { return add(1, 3); }
+    `;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(4);
+    expect(r.conf).toBe("exact");
+  });
+
+  it("scale(x) = add(x,1) under x>0 ⇒ (x+1)>1", () => {
+    const src = `
+      const add = (a, b) => a + b;
+      function scale(x) { return add(x, 1); }
+    `;
+    const phi = gtNum(v("x"), 0);
+    const r = analyzeFn(src, "scale", [numVar("x", gtNum(v("x"), 0))], phi);
+    expect(r.term).toBeDefined();
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred!.op).toBe("gt");
+    if (r.pred!.op === "gt") {
+      expect(r.pred!.b).toEqual(lit(1));
+    }
+  });
+
+  it("twice(x) nested add under x>0 ⇒ >2", () => {
+    const src = `
+      const add = (a, b) => a + b;
+      function twice(x) {
+        const c = add(x, 1);
+        return add(c, 1);
+      }
+    `;
+    const phi = gtNum(v("x"), 0);
+    const r = analyzeFn(src, "twice", [numVar("x", gtNum(v("x"), 0))], phi);
+    expect(r.term).toBeDefined();
+    expect(r.pred).toBeDefined();
+    // ((x+1)+1) > 2 或 (x+2) > 2
+    const ps = predToString(r.pred!);
+    expect(ps).toContain("2");
+  });
+
+  it("if (x > 5) return x; return 0  with x>10 ⇒ x", () => {
+    const src = `
+      function pick(x) {
+        if (x > 5) return x;
+        return 0;
+      }
+    `;
+    const phi = gtNum(v("x"), 10);
+    const r = analyzeFn(src, "pick", [numVar("x", gtNum(v("x"), 10))], phi);
+    // true 分支返回 x（term=x），false 分支 0；join 后丢 term
+    // 但 true 分支在 Φ 下 x>5 成立，我们至少得到 number
+    expect(r.shape).toEqual({ k: "prim", type: "number" });
+  });
+
+  it("if (x > 0) return x + 1; return 0  with Φ x>0 ⇒ true branch", () => {
+    const src = `
+      function addOneIfPositive(x) {
+        if (x > 0) return x + 1;
+        return 0;
+      }
+    `;
+    const phi = gtNum(v("x"), 0);
+    const r = analyzeFn(src, "addOneIfPositive", [numVar("x", gtNum(v("x"), 0))], phi);
+    expect(termToString(r.term!)).toBe("(x + 1)");
+    expect(r.pred!.op).toBe("gt");
+  });
+
+  it("literal only function", () => {
+    const src = `
+      function f() { return 1 + 2 * 3; }
+    `;
+    // 注意：JS 里 1+2*3 = 7，我们的 BinaryExpression 是左结合遍历
+    // Babel AST: (1 + (2 * 3)) —— 乘法优先，AST 已带优先级
+    const r = analyzeFn(src, "f", []);
+    expect(litValue(r)).toBe(7);
+  });
+
+  it("string concat from source", () => {
+    const src = `
+      function greet(name) { return "hi, " + name; }
+    `;
+    const r = analyzeFn(src, "greet", [numLit(1)]);
+    // number + string 在 JS 里是字符串，我们 isStrPrim 一侧即可
+    // 实参是 number，左侧是 string → 走 string 拼接
+    expect(r.shape).toEqual({ k: "prim", type: "string" });
+  });
+});
+
+describe("leak", () => {
+  it("small term does not leak", () => {
+    resetLeakCounter();
+    const t = app("+", [v("x"), lit(1)]);
+    expect(exceedsBudget(t)).toBe(false);
+    const a = add(numVar("x"), numLit(1));
+    const leaked = leakIfNeeded(a);
+    expect(leaked.term).toEqual(a.term);
+  });
+
+  it("deep term leaks to fresh var + eq", () => {
+    resetLeakCounter();
+    let t = v("x");
+    for (let i = 0; i < 10; i++) {
+      t = app("+", [t, lit(1)]);
+    }
+    expect(termDepth(t)).toBeGreaterThan(6);
+    expect(exceedsBudget(t)).toBe(true);
+
+    const a = { shape: { k: "prim" as const, type: "number" as const }, term: t, conf: "path" as const };
+    const leaked = maybeLeak(a, { maxDepth: 4, maxNodes: 20 }, "acc");
+    expect(leaked.term?.op).toBe("var");
+    if (leaked.term?.op === "var") {
+      expect(leaked.term.id.startsWith("acc$")).toBe(true);
+    }
+    expect(leaked.pred?.op).toBe("eq");
+  });
+});
+
+describe("mul negative flips bounds", () => {
+  it("x>0 * -2 ⇒ (x*-2) < 0", () => {
+    const phi = gtNum(v("x"), 0);
+    const r = mul(numVar("x", gtNum(v("x"), 0)), numLit(-2), phi);
+    expect(r.pred).toBeDefined();
+    expect(r.pred!.op).toBe("lt");
+    if (r.pred!.op === "lt") {
+      expect(r.pred!.b).toEqual(lit(0));
+    }
+  });
+});

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

@@ -0,0 +1,160 @@
+import { describe, it, expect } from "vitest";
+import {
+  absToTypeValue,
+  typeValueToAbs,
+  bridgeIsLossy,
+  getTvConfidence,
+  numLit,
+  numVar,
+  gtNum,
+  v,
+  litValue,
+  formatShape,
+  analyzeFn,
+  objOf,
+  strLit,
+  boolLit,
+} from "../index.ts";
+import { typeValueToString, T } from "../../type-value.ts";
+
+describe("bridge Abs → TypeValue", () => {
+  it("literal 4 → literal 4 #exact", () => {
+    const tv = absToTypeValue(numLit(4));
+    expect(tv.kind).toBe("literal");
+    if (tv.kind === "literal") expect(tv.value).toBe(4);
+    expect(getTvConfidence(tv)).toBe("exact");
+  });
+
+  it("plain number prim → primitive number", () => {
+    const tv = absToTypeValue({
+      shape: { k: "prim", type: "number" },
+      conf: "exact",
+    });
+    expect(typeValueToString(tv)).toBe("number");
+  });
+
+  it("x>0 with pred → refined number", () => {
+    const a = numVar("x", gtNum(v("x"), 0));
+    const tv = absToTypeValue(a);
+    // term 是 var，会丢 term；pred 可 encode 为 refined
+    expect(tv.kind === "refined" || tv.kind === "primitive").toBe(true);
+    const lossy = bridgeIsLossy(a);
+    // 丢 term 是预期的
+    expect(lossy.reasons.some((r) => r.includes("term"))).toBe(true);
+  });
+
+  it("object slots map to object TypeValue", () => {
+    const o = objOf({
+      host: { value: strLit("localhost") },
+      port: { value: numLit(8080) },
+      debug: { value: boolLit(false) },
+    });
+    const tv = absToTypeValue(o);
+    expect(tv.kind).toBe("object");
+    expect(typeValueToString(tv)).toContain("host");
+    expect(typeValueToString(tv)).toContain("8080");
+  });
+});
+
+describe("bridge TypeValue → Abs", () => {
+  it("literal 6 → Abs exact 6", () => {
+    const abs = typeValueToAbs(T.literal(6));
+    expect(litValue(abs)).toBe(6);
+    expect(abs.conf).toBe("exact");
+  });
+
+  it("primitive string → prim string", () => {
+    const abs = typeValueToAbs(T.string);
+    expect(formatShape(abs)).toBe("string");
+  });
+
+  it("object → obj slots", () => {
+    const abs = typeValueToAbs(
+      T.object({ a: T.literal(1), b: T.string }),
+    );
+    expect(abs.shape.k).toBe("obj");
+  });
+
+  it("round-trip literal", () => {
+    const tv = absToTypeValue(numLit(42));
+    const back = typeValueToAbs(tv);
+    expect(litValue(back)).toBe(42);
+  });
+
+  it("round-trip primitive (lossless)", () => {
+    const abs0 = {
+      shape: { k: "prim" as const, type: "number" as const },
+      conf: "exact" as const,
+    };
+    const tv = absToTypeValue(abs0);
+    const back = typeValueToAbs(tv);
+    expect(formatShape(back)).toBe("number");
+  });
+});
+
+describe("bridgeIsLossy", () => {
+  it("literal is not lossy", () => {
+    expect(bridgeIsLossy(numLit(1)).lossy).toBe(false);
+  });
+  it("symbolic term is lossy", () => {
+    const src = `
+      function scale(x) { return x + 1; }
+    `;
+    const r = analyzeFn(src, "scale", [numVar("x")]);
+    expect(bridgeIsLossy(r).lossy).toBe(true);
+  });
+});
+
+describe("bridge any / conf / refined reverse (rewrite closeout)", () => {
+  it("Abs any projects as unknown but keeps path conf (not partial)", () => {
+    const a: import("../abs.ts").Abs = { shape: { k: "any" }, conf: "path" };
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("unknown");
+    expect(getTvConfidence(tv)).toBe("path");
+  });
+
+  it("Abs analysis-fail unknown keeps partial conf", () => {
+    const a: import("../abs.ts").Abs = { shape: { k: "unknown" }, conf: "partial" };
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("unknown");
+    expect(getTvConfidence(tv)).toBe("partial");
+  });
+
+  it("widened TypeValue does not round-trip as exact", () => {
+    const src = `
+      function scale(x) { return x + 1; }
+    `;
+    const r = analyzeFn(src, "scale", [numVar("x")]);
+    const tv = absToTypeValue(r);
+    const back = typeValueToAbs(tv);
+    expect(back.conf === "exact").toBe(false);
+  });
+
+  it("refined numeric pred reverse-encodes into Abs pred", () => {
+    const a = numVar("x", gtNum(v("x"), 0));
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("refined");
+    const back = typeValueToAbs(tv);
+    expect(back.shape.k).toBe("prim");
+    expect(back.pred).toBeDefined();
+    expect(back.pred!.op).toBe("gt");
+    // pred 右端恢复为字面量 0
+    if (back.pred!.op === "gt") {
+      expect(back.pred!.b.op).toBe("lit");
+      if (back.pred!.b.op === "lit") expect(back.pred!.b.value).toBe(0);
+    }
+  });
+
+  it("refined le reverse-encodes", () => {
+    const a: import("../abs.ts").Abs = {
+      shape: { k: "prim", type: "number" },
+      term: v("n"),
+      pred: { op: "le", a: v("n"), b: { op: "lit", value: 10 } },
+      conf: "path",
+    };
+    const tv = absToTypeValue(a);
+    expect(tv.kind).toBe("refined");
+    const back = typeValueToAbs(tv);
+    expect(back.pred?.op).toBe("le");
+  });
+});

package/src/algebra/__tests__/call-budget.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from "vitest";
+import { checkSource } from "../check.ts";
+import {
+  analyzeFn,
+  evalProgramAbs,
+  resetAbsCallBudget,
+  MAX_CALL_DEPTH,
+} from "../ast-eval.ts";
+import { pTrue } from "../pred.ts";
+import { num, unknown } from "../abs.ts";
+import type { Abs } from "../abs.ts";
+
+const FAC = `
+function fac(n) {
+  if (n <= 1) return 1;
+  return n * fac(n - 1);
+}
+`;
+
+const FIB = `
+function fib(n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}
+`;
+
+const MUTUAL = `
+function isEven(n) {
+  if (n === 0) return true;
+  return isOdd(n - 1);
+}
+function isOdd(n) {
+  if (n === 0) return false;
+  return isEven(n - 1);
+}
+`;
+
+describe("Abs call budget (recursion guard)", () => {
+  it("analyzeFn on factorial does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(FAC, "fac", [num()], pTrue);
+    expect(r).toBeDefined();
+    expect(r.shape.k === "unknown" || r.shape.k === "prim" || r.shape.k === "never").toBe(true);
+  });
+
+  it("analyzeFn on fib does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(FIB, "fib", [num()], pTrue);
+    expect(r).toBeDefined();
+  });
+
+  it("mutual recursion does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(MUTUAL, "isEven", [num()], pTrue);
+    expect(r).toBeDefined();
+  });
+
+  it("evalProgramAbs with top-level recursive call does not stack-overflow", () => {
+    resetAbsCallBudget();
+    const { last } = evalProgramAbs(`
+function count(n) {
+  if (n <= 0) return 0;
+  return 1 + count(n - 1);
+}
+const x = count(5);
+`);
+    expect(last).toBeDefined();
+  });
+
+  it("concrete base-case recursion still evaluates", () => {
+    // 调用深度在 64 内：count(5) 应给出字面量结果而非 opaque
+    resetAbsCallBudget();
+    const lit5: Abs = {
+      shape: { k: "prim", type: "number" },
+      term: { op: "lit", value: 5 },
+      conf: "exact",
+    };
+    const r = analyzeFn(
+      `
+function count(n) {
+  if (n <= 0) return 0;
+  return 1 + count(n - 1);
+}
+`,
+      "count",
+      [lit5],
+      pTrue,
+    );
+    // 5 层展开应收敛为字面量 5（或至少 number）
+    expect(r.shape.k === "prim" || r.shape.k === "never").toBe(true);
+    if (r.term && r.term.op === "lit") {
+      expect(r.term.value).toBe(5);
+    }
+  });
+
+  it("checkSource completes on factorial with structured diagnostics", () => {
+    const report = checkSource("/tmp/fac.js", FAC, pTrue, {});
+    expect(report).toBeDefined();
+    // 不得崩溃；递归截断记 warning
+    const codes = report.issues.map((i) => i.code);
+    expect(codes).toContain("nudo:recursion-truncated");
+    expect(report.issues.every((i) => i.severity !== undefined)).toBe(true);
+  });
+
+  it("depth budget constant is aligned with TypeValue evaluator", () => {
+    expect(MAX_CALL_DEPTH).toBe(64);
+  });
+
+  it("truncated result uses opaque conf, not partial-any", () => {
+    resetAbsCallBudget();
+    const r = analyzeFn(FAC, "fac", [num()], pTrue);
+    // 截断后应为 unknown+opaque，或仍能算出的 prim；绝不能是 exact 的假结果
+    if (r.shape.k === "unknown") {
+      expect(r.conf === "opaque" || r.conf === "partial" || r.conf === "widened").toBe(true);
+    }
+  });
+});

package/src/algebra/__tests__/check-case-consistency.test.ts

@@ -0,0 +1,69 @@
+/**
+ * case ⊄ refine → nudo:case-inconsistency
+ * case 是契约的见证，不是另一套前置来源。
+ */
+import { describe, it, expect } from "vitest";
+import { checkSource, pTrue } from "../index.ts";
+import { withStdImport, stdOpts } from "./nudo-constraints.ts";
+
+function issuesOf(src: string) {
+  return checkSource("/t/case.js", withStdImport(src), pTrue, stdOpts);
+}
+
+describe("case vs refine", () => {
+  it("ok: case 实参满足契约", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:refine x positive
+ * @nudo:case "ok" (5)
+ */
+function needsPositive(x) {
+  return x;
+}
+`);
+    expect(r.issues.filter((i) => i.code === "nudo:case-inconsistency")).toEqual([]);
+  });
+
+  it("error: case 实参 ⊭ refine", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:refine x positive
+ * @nudo:case "neg" (-1)
+ */
+function needsPositive(x) {
+  return x;
+}
+`);
+    const err = r.issues.find((i) => i.code === "nudo:case-inconsistency");
+    expect(err).toBeDefined();
+    expect(err!.severity).toBe("error");
+    expect(err!.expected).toContain(">");
+    expect(err!.message).toContain("neg");
+  });
+
+  it("error: percent 上界违例", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:refine n percent
+ * @nudo:case "big" (150)
+ */
+function pct(n) {
+  return n;
+}
+`);
+    expect(r.ok).toBe(false);
+    expect(r.issues.some((i) => i.code === "nudo:case-inconsistency")).toBe(true);
+  });
+
+  it("ok: 无 refine 的 case 不报", () => {
+    const r = issuesOf(`
+/**
+ * @nudo:case "any" (-1)
+ */
+function id(x) {
+  return x;
+}
+`);
+    expect(r.issues.filter((i) => i.code === "nudo:case-inconsistency")).toEqual([]);
+  });
+});