@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/__tests__/exec-spread-forof.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  $obj,
-  $arr,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path spread", () => {
-  it("object spread overwrites keys", () => {
-    const src = `
-export function go() {
-  const a = { x: 1, y: 2 };
-  const b = { y: 9, z: 3 };
-  const o = { ...a, ...b };
-  return o.x + o.y + o.z;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(13); // 1+9+3
-  });
-
-  it("array spread concatenates", () => {
-    const src = `
-export function go() {
-  const a = [1, 2];
-  const b = [3];
-  const c = [...a, ...b];
-  return c[0] + c[1] + c[2];
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(6);
-  });
-
-  it("transpiles spread", () => {
-    const out = transpile(`export function f(a, b) { return { ...a, z: 1 }; }`);
-    expect(out).toContain("$spread(");
-  });
-});
-
-describe("B-path for-of", () => {
-  it("iterates tuple elements", () => {
-    const src = `
-export function go() {
-  const xs = [1, 2, 3];
-  let sum = 0;
-  for (const x of xs) {
-    sum = sum + x;
-  }
-  return sum;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(6);
-  });
-
-  it("for-of with object destructure", () => {
-    const src = `
-export function go() {
-  const xs = [{ v: 1 }, { v: 2 }];
-  let sum = 0;
-  for (const { v } of xs) {
-    sum = sum + v;
-  }
-  return sum;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(3);
-  });
-
-  it("transpiles for-of", () => {
-    const out = transpile(`export function f(xs) { let t = 0; for (const x of xs) { t = t + x; } return t; }`);
-    expect(out).toContain("$forOf(");
-  });
-});

package/src/algebra/__tests__/exec-static-computed.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path class static members", () => {
-  it("reads static fields and calls static methods", () => {
-    const src = `
-class Point {
-  static origin = 0;
-  static make(n) { return n * 2; }
-  constructor(x) { this.x = x; }
-  get() { return this.x; }
-}
-export function go() {
-  const p = new Point(Point.make(3));
-  return p.get() + Point.origin;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(6); // make(3)=6 + origin=0
-  });
-
-  it("transpiles static to $class statics/staticMethods", () => {
-    const out = transpile(`
-class C {
-  static n = 1;
-  static f() { return 2; }
-  m() { return 3; }
-}
-`);
-    expect(out).toContain("statics:");
-    expect(out).toContain("staticMethods:");
-  });
-});
-
-describe("B-path computed object properties", () => {
-  it("{ [k]: v } uses $setKey", () => {
-    const src = `
-export function go() {
-  const k = "id";
-  const o = { [k]: 7 };
-  return o.id;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(7);
-  });
-
-  it("transpiles computed property", () => {
-    const out = transpile(`export function f(k, v) { return { [k]: v }; }`);
-    expect(out).toContain("$setKey(");
-  });
-});

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

@@ -1,74 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path switch", () => {
-  it("selects matching case by concrete disc", () => {
-    const src = `
-export function go(n) {
-  switch (n) {
-    case 1:
-      return "one";
-    case 2:
-      return "two";
-    default:
-      return "other";
-  }
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    expect(litValue(callTranspiledExportFull(exports, "go", [$lit(1)]).result)).toBe("one");
-    expect(litValue(callTranspiledExportFull(exports, "go", [$lit(2)]).result)).toBe("two");
-    expect(litValue(callTranspiledExportFull(exports, "go", [$lit(9)]).result)).toBe("other");
-  });
-
-  it("handles fall-through", () => {
-    const src = `
-export function go(n) {
-  switch (n) {
-    case 1:
-    case 2:
-      return "small";
-    case 3:
-      return "three";
-    default:
-      return "big";
-  }
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    expect(litValue(callTranspiledExportFull(exports, "go", [$lit(1)]).result)).toBe("small");
-    expect(litValue(callTranspiledExportFull(exports, "go", [$lit(2)]).result)).toBe("small");
-    expect(litValue(callTranspiledExportFull(exports, "go", [$lit(3)]).result)).toBe("three");
-  });
-
-  it("abstract disc joins branches", () => {
-    const src = `
-export function go(n) {
-  switch (n) {
-    case 1:
-      return 10;
-    default:
-      return 20;
-  }
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", [
-      { shape: { k: "prim", type: "number" }, conf: "exact" },
-    ]);
-    // 抽象 number → join(10, 20) → number #path
-    expect(absToString(r.result)).toContain("number");
-  });
-
-  it("transpiles switch to $switch", () => {
-    const out = transpile(`export function f(n) { switch (n) { case 1: return 1; default: return 0; } }`);
-    expect(out).toContain("$switch(");
-  });
-});

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

@@ -1,71 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path try/catch", () => {
-  it("catches $throw and binds Abs value", () => {
-    const src = `
-export function go(n) {
-  try {
-    if (n > 0) {
-      return n;
-    } else {
-      throw "neg";
-    }
-  } catch (e) {
-    return e;
-  }
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const ok = callTranspiledExportFull(exports, "go", [$lit(3)]);
-    expect(litValue(ok.result)).toBe(3);
-    expect(ok.throws.shape.k).toBe("never");
-
-    const bad = callTranspiledExportFull(exports, "go", [$lit(-1)]);
-    expect(litValue(bad.result)).toBe("neg");
-  });
-
-  it("finally runs after catch", () => {
-    const src = `
-export function go() {
-  let t = 0;
-  try {
-    throw "x";
-  } catch (e) {
-    t = 1;
-  } finally {
-    t = t + 10;
-  }
-  return t;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(11);
-  });
-
-  it("uncaught throw still reports throws", () => {
-    const src = `
-export function go() {
-  throw "boom";
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(r.result.shape.k).toBe("never");
-    expect(absToString(r.throws)).toContain("boom");
-  });
-
-  it("transpiles try/catch", () => {
-    const out = transpile(`export function f() { try { return 1; } catch (e) { return 0; } }`);
-    expect(out).toContain("try {");
-    expect(out).toContain("$catchVal(");
-  });
-});

package/src/algebra/__tests__/fn-fp-memo.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  canSkipLiteralCallScan,
-  generalizeFromAst,
-  resetGeneralizeMemo,
-  getGeneralizeMemoSize,
-  parseSource,
-} from "../index.ts";
-
-const BASE = `
-function alpha(x) {
-  return x + 1;
-}
-function beta(y) {
-  return y * 2;
-}
-function gamma(z) {
-  return alpha(z) + beta(z);
-}
-`;
-
-beforeEach(() => {
-  resetGeneralizeMemo();
-});
-
-describe("per-function L0 fingerprints", () => {
-  it("editing one independent function does not miss another", () => {
-    const file0 = parseSource(BASE);
-    const a0 = generalizeFromAst("alpha", BASE, { file: file0 });
-    const b0 = generalizeFromAst("beta", BASE, { file: file0 });
-    expect(a0).toBeDefined();
-    expect(b0).toBeDefined();
-
-    const edited = BASE.replace("return y * 2;", "return y * 3;");
-    const file1 = parseSource(edited);
-    // beta changed -> new PolyFn
-    const b1 = generalizeFromAst("beta", edited, { file: file1 });
-    expect(b1).toBeDefined();
-    expect(b1).not.toBe(b0);
-    // alpha unchanged and does not reference beta -> same instance
-    const a1 = generalizeFromAst("alpha", edited, { file: file1 });
-    expect(a1).toBe(a0);
-  });
-
-  it("caller misses when callee body changes", () => {
-    const file0 = parseSource(BASE);
-    const g0 = generalizeFromAst("gamma", BASE, { file: file0 });
-    const a0 = generalizeFromAst("alpha", BASE, { file: file0 });
-
-    const edited = BASE.replace("return x + 1;", "return x + 10;");
-    const file1 = parseSource(edited);
-    const a1 = generalizeFromAst("alpha", edited, { file: file1 });
-    const g1 = generalizeFromAst("gamma", edited, { file: file1 });
-    expect(a1).not.toBe(a0);
-    expect(g1).not.toBe(g0);
-  });
-
-  it("top-level non-function context change misses all", () => {
-    const src = `const K = 1;\nfunction alpha(x) { return x + K; }\nfunction beta(y) { return y; }\n`;
-    const file0 = parseSource(src);
-    const a0 = generalizeFromAst("alpha", src, { file: file0 });
-    const b0 = generalizeFromAst("beta", src, { file: file0 });
-
-    const edited = `const K = 2;\nfunction alpha(x) { return x + K; }\nfunction beta(y) { return y; }\n`;
-    const file1 = parseSource(edited);
-    const a1 = generalizeFromAst("alpha", edited, { file: file1 });
-    const b1 = generalizeFromAst("beta", edited, { file: file1 });
-    expect(a1).not.toBe(a0);
-    expect(b1).not.toBe(b0);
-  });
-
-  it("without file AST falls back to whole-source key", () => {
-    const a0 = generalizeFromAst("alpha", BASE);
-    const edited = BASE.replace("return y * 2;", "return y * 3;");
-    const a1 = generalizeFromAst("alpha", edited);
-    // no file -> whole source hash, alpha misses too
-    expect(a1).not.toBe(a0);
-  });
-
-  it("refine leading comments are part of own slice", () => {
-    const src1 = `
-/**
- * @nudo:case "c" (1)
- */
-function f(x) { return x + 1; }
-`;
-    const src2 = `
-/**
- * @nudo:case "c" (2)
- */
-function f(x) { return x + 1; }
-`;
-    const g1 = generalizeFromAst("f", src1, { file: parseSource(src1) });
-    const g2 = generalizeFromAst("f", src2, { file: parseSource(src2) });
-    expect(g1).toBeDefined();
-    expect(g2).toBeDefined();
-    expect(g2).not.toBe(g1);
-  });
-
-  it("memo size grows with distinct fingerprints only", () => {
-    const file = parseSource(BASE);
-    generalizeFromAst("alpha", BASE, { file });
-    generalizeFromAst("beta", BASE, { file });
-    const n = getGeneralizeMemoSize();
-    generalizeFromAst("alpha", BASE, { file });
-    expect(getGeneralizeMemoSize()).toBe(n);
-  });
-
-  it("default-param sibling reference dirties caller L0", () => {
-    const src1 = `
-function helper() { return 1; }
-function f(a = helper()) { return a; }
-`;
-    const src2 = `
-function helper() { return 2; }
-function f(a = helper()) { return a; }
-`;
-    const g1 = generalizeFromAst("f", src1, { file: parseSource(src1) });
-    const g2 = generalizeFromAst("f", src2, { file: parseSource(src2) });
-    expect(g1).toBeDefined();
-    expect(g2).toBeDefined();
-    expect(g2).not.toBe(g1);
-  });
-
-  it("multi-declarator leading refine comment is part of own slice", () => {
-    const src1 = `
-const f = (x) => x,
-  /**
-   * @nudo:case "c" (1)
-   */
-  g = (y) => y + 1;
-`;
-    const src2 = `
-const f = (x) => x,
-  /**
-   * @nudo:case "c" (2)
-   */
-  g = (y) => y + 1;
-`;
-    const g1 = generalizeFromAst("g", src1, { file: parseSource(src1) });
-    const g2 = generalizeFromAst("g", src2, { file: parseSource(src2) });
-    expect(g1).toBeDefined();
-    expect(g2).toBeDefined();
-    expect(g2).not.toBe(g1);
-  });
-});
-
-describe("canSkipLiteralCallScan depth cap", () => {
-  it("does not skip when a call sits below the walk depth cap", () => {
-    // 90 nested arrays push the CallExpression past hasAnyCallLike's depth>80
-    // cut-off. Unexplored subtrees must be treated as "may contain a call".
-    let nest = "f(-1)";
-    for (let i = 0; i < 90; i++) nest = `[${nest}]`;
-    const src = `const x = ${nest};\n`;
-    const file = parseSource(src);
-    expect(canSkipLiteralCallScan(src, file)).toBe(false);
-  });
-
-  it("still skips shallow call-free sources", () => {
-    const src = `function id(x) { return x + 1; }\nconst y = id(2);\n`;
-    // id(2) is a CallExpression — must NOT skip
-    expect(canSkipLiteralCallScan(src, parseSource(src))).toBe(false);
-    const pure = `const y = 1 + 2;\nfunction id(x) { return x + 1; }\n`;
-    expect(canSkipLiteralCallScan(pure, parseSource(pure))).toBe(true);
-  });
-});

package/src/algebra/__tests__/fn-fp-multidecl.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  generalizeFromAst,
-  resetGeneralizeMemo,
-  parseSource,
-  fnFingerprints,
-} from "../index.ts";
-
-const SRC = `const a = (x) => x, b = (x) => x + 1;
-function gamma(x) { return b(x); }
-`;
-
-beforeEach(() => {
-  resetGeneralizeMemo();
-});
-
-describe("multi-declarator fingerprints", () => {
-  it("indexes every function declarator", () => {
-    const fps = fnFingerprints(SRC, parseSource(SRC));
-    expect([...fps.keys()].sort()).toEqual(["a", "b", "gamma"]);
-  });
-
-  it("caller misses L0 when callee in same declarator statement changes", () => {
-    const f0 = parseSource(SRC);
-    const g0 = generalizeFromAst("gamma", SRC, { file: f0 });
-    expect(g0).toBeDefined();
-
-    const edited = SRC.replace("b = (x) => x + 1", "b = (x) => x + 10");
-    const f1 = parseSource(edited);
-    const g1 = generalizeFromAst("gamma", edited, { file: f1 });
-    expect(g1).not.toBe(g0);
-  });
-
-  it("independent sibling in same statement does not dirty the other's callers", () => {
-    const f0 = parseSource(SRC);
-    const a0 = generalizeFromAst("a", SRC, { file: f0 });
-    const g0 = generalizeFromAst("gamma", SRC, { file: f0 });
-    expect(a0).toBeDefined();
-    expect(g0).toBeDefined();
-
-    // Only a changes; gamma calls b — a's own-slice must not drag gamma.
-    const edited = SRC.replace("a = (x) => x", "a = (x) => x + 100");
-    const f1 = parseSource(edited);
-    const a1 = generalizeFromAst("a", edited, { file: f1 });
-    const g1 = generalizeFromAst("gamma", edited, { file: f1 });
-    expect(a1).not.toBe(a0);
-    expect(g1).toBe(g0);
-  });
-});

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

@@ -1,34 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatShape, formatAbs } from "../format.ts";
-import { abs, num } from "../abs.ts";
-import { v, lit } from "../term.ts";
-import { ge } from "../pred.ts";
-
-describe("formatShape brand/eff/fn", () => {
-  it("brand shows class name", () => {
-    const inner = abs(num().shape, undefined, undefined, "exact");
-    const a = abs({ k: "brand", name: "Counter", shape: inner }, undefined, undefined, "exact");
-    expect(formatShape(a)).toBe("Counter");
-  });
-
-  it("eff shows promise inner", () => {
-    const inner = abs(num().shape, undefined, undefined, "exact");
-    const a = abs({ k: "eff", eff: "promise", inner }, undefined, undefined, "exact");
-    expect(formatShape(a)).toBe("promise<number>");
-  });
-
-  it("fn shows return shape when present", () => {
-    const a = abs(
-      { k: "fn", params: ["x"], returnType: abs(num().shape, undefined, undefined, "exact") },
-      undefined,
-      undefined,
-      "exact",
-    );
-    expect(formatShape(a)).toBe("(x) => number");
-  });
-
-  it("formatAbs still includes pred", () => {
-    const a = abs(num().shape, v("x"), ge(v("x"), lit(0)), "path");
-    expect(formatAbs(a)).toContain("0");
-  });
-});