@nudojs/core 0.1.0 → 0.3.0

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

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { typeofAbs, negAbs, notAbs, strictEqAbs } from "../surface.ts";
+import { numLit, num, abs, strLit, boolLit } from "../abs.ts";
+import { lit, v } from "../term.ts";
+import { gt, pTrue } from "../pred.ts";
+import { typeValueToString } from "../../type-value.ts";
+import { absToTypeValue } from "../bridge.ts";
+
+describe("algebra surface ops", () => {
+  it("typeof of primitives and null", () => {
+    expect(typeValueToString(absToTypeValue(typeofAbs(numLit(1))))).toBe('"number"');
+    expect(typeValueToString(absToTypeValue(typeofAbs(strLit("x"))))).toBe('"string"');
+    expect(typeValueToString(absToTypeValue(typeofAbs(abs({ k: "unknown" }, lit(null), pTrue, "exact"))))).toBe('"object"');
+    expect(typeValueToString(absToTypeValue(typeofAbs(abs({ k: "fn", params: [] }, undefined, undefined, "exact"))))).toBe('"function"');
+  });
+
+  it("typeof of unknown is abstract string (JS always returns string)", () => {
+    const r = typeofAbs(abs({ k: "unknown" }, undefined, undefined, "partial"));
+    expect(r.shape).toEqual({ k: "prim", type: "string" });
+  });
+
+  it("neg folds and flips bounds", () => {
+    expect(typeValueToString(absToTypeValue(negAbs(numLit(5))))).toBe("-5");
+    const x = abs(num().shape, v("x"), gt(v("x"), lit(0)), "path");
+    const nx = negAbs(x);
+    expect(nx.term).toBeDefined();
+    expect(nx.pred).toBeDefined();
+  });
+
+  it("not folds literals including undefined", () => {
+    expect(typeValueToString(absToTypeValue(notAbs(boolLit(false))))).toBe("true");
+    expect(typeValueToString(absToTypeValue(notAbs(abs({ k: "unknown" }, lit(undefined), pTrue, "exact"))))).toBe("true");
+  });
+
+  it("strictEq nullish vs number is false", () => {
+    const n = abs(num().shape, undefined, undefined, "exact");
+    const nul = abs({ k: "unknown" }, lit(null), pTrue, "exact");
+    expect(strictEqAbs(n, nul)).toBe(false);
+    expect(strictEqAbs(numLit(1), numLit(1))).toBe(true);
+  });
+});

package/src/algebra/__tests__/this-inherit.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import { analyzeFn, numLit, litValue, formatShape } from "../index.ts";
+
+describe("this method body + inheritance", () => {
+  it("method reads this field set in constructor", () => {
+    const src = `
+class Counter {
+  constructor(n) { this.n = n; }
+  get() { return this.n; }
+}
+function main() {
+  const c = new Counter(3);
+  return c.get();
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(3);
+    expect(r.conf).toBe("exact");
+  });
+
+  it("method arithmetic on this", () => {
+    const src = `
+class Acc {
+  constructor(n) { this.n = n; }
+  add(k) { return this.n + k; }
+}
+function main() {
+  return new Acc(10).add(5);
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(15);
+  });
+
+  it("inherited method via super class shape", () => {
+    const src = `
+class Base {
+  hello() { return "hi"; }
+}
+class Child extends Base {
+  hello() { return "child"; }
+}
+function main() {
+  return new Child().hello();
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    // 子类覆写
+    expect(litValue(r)).toBe("child");
+  });
+
+  it("inherited method not overridden", () => {
+    const src = `
+class Base {
+  hello() { return "hi"; }
+  n() { return 1; }
+}
+class Child extends Base {
+  hello() { return "child"; }
+}
+function main() {
+  return new Child().n();
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(1);
+  });
+
+  it("instanceof super class name → true", () => {
+    const src = `
+class Base { x() { return 1; } }
+class Child extends Base { y() { return 2; } }
+function main() {
+  return new Child() instanceof Base;
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(true);
+  });
+
+  it("super.method() dispatches to parent", () => {
+    const src = `
+class Base {
+  hello() { return "hi"; }
+}
+class Child extends Base {
+  hello() { return super.hello() + "!"; }
+}
+function main() {
+  return new Child().hello();
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe("hi!");
+    expect(r.conf).toBe("exact");
+  });
+
+  it("inherited constructor writes this fields", () => {
+    const src = `
+class Base {
+  constructor(n) { this.n = n; }
+}
+class Child extends Base {
+  double() { return this.n * 2; }
+}
+function main() {
+  return new Child(4).double();
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(8);
+  });
+
+  it("super in multi-level chain", () => {
+    const src = `
+class A { m() { return 1; } }
+class B extends A {
+  m() { return super.m() + 1; }
+}
+class C extends B {
+  m() { return super.m() + 1; }
+}
+function main() {
+  return new C().m();
+}
+`;
+    const r = analyzeFn(src, "main", []);
+    expect(litValue(r)).toBe(3);
+  });
+});

package/src/algebra/abs-fn.ts

@@ -0,0 +1,49 @@
+/**
+ * Abs 上的一等函数：shape 是 fn，实现在旁路（不污染 Shape）。
+ * 与 term-registry 同一纪律：不给共享单例挂 impl。
+ */
+
+import type { Node } from "@babel/types";
+import type { Abs } from "./abs.ts";
+import type { AstEnv } from "./ast-eval.ts";
+
+export type AbsFnImpl = {
+  params: string[];
+  body: Node;
+  async?: boolean;
+  /** 声明时捕获的环境（闭包） */
+  env?: AstEnv;
+  kind?: string;
+  /** 调用时直接派发（mock withArgs 等），优先于 body */
+  apply?: (args: Abs[]) => Abs;
+  /**
+   * Optional content key for cache fingerprints. formatAbs cannot see
+   * WeakMap-side mock semantics (returns/withArgs/callsFake), so hosts that
+   * build mocks should stamp a stable fingerprint here.
+   */
+  fingerprint?: string;
+};
+
+const implByAbs = new WeakMap<object, AbsFnImpl>();
+
+export function attachFnImpl(a: Abs, impl: AbsFnImpl): void {
+  if (a && typeof a === "object") implByAbs.set(a as object, impl);
+}
+
+export function getFnImpl(a: Abs): AbsFnImpl | undefined {
+  if (!a || typeof a !== "object") return undefined;
+  return implByAbs.get(a as object);
+}
+
+/** 造一个带实现的 Abs 函数值 */
+export function absFunction(
+  params: string[],
+  impl: Omit<AbsFnImpl, "params">,
+): Abs {
+  const a: Abs = {
+    shape: { k: "fn", params },
+    conf: "exact",
+  };
+  attachFnImpl(a, { params, ...impl });
+  return a;
+}

package/src/algebra/abs-modules.ts

@@ -0,0 +1,139 @@
+/**
+ * Abs 模块面（无 fs）：import 绑定 + export 收集。
+ * 解析路径/读文件在 host；core 只吃「specifier → 导出表」。
+ */
+
+import type { File, ImportDeclaration } from "@babel/types";
+import type { Abs } from "./abs.ts";
+import { unknown, obj } from "./abs.ts";
+import type { AstEnv } from "./ast-eval.ts";
+import { absFunction } from "./abs-fn.ts";
+
+export type AbsModuleExports = {
+  named: Record<string, Abs>;
+  default?: Abs;
+};
+
+/** 把 import 说明符绑定进 env（宿主已求值依赖） */
+export function bindImports(
+  node: ImportDeclaration,
+  env: AstEnv,
+  modules: Record<string, AbsModuleExports>,
+): void {
+  const mod = modules[node.source.value];
+  if (!mod) {
+    for (const s of node.specifiers) {
+      env.vars.set(s.local.name, unknown);
+    }
+    return;
+  }
+  for (const s of node.specifiers) {
+    if (s.type === "ImportDefaultSpecifier") {
+      env.vars.set(s.local.name, mod.default ?? unknown);
+    } else if (s.type === "ImportSpecifier") {
+      const imported = s.imported.type === "Identifier" ? s.imported.name : String(s.imported);
+      env.vars.set(s.local.name, mod.named[imported] ?? unknown);
+    } else if (s.type === "ImportNamespaceSpecifier") {
+      const slots: Record<string, { value: Abs }> = {};
+      for (const [k, v] of Object.entries(mod.named)) slots[k] = { value: v };
+      if (mod.default) slots["default"] = { value: mod.default };
+      env.vars.set(s.local.name, obj(slots));
+    }
+  }
+}
+
+function fnToAbs(env: AstEnv, name: string): Abs | undefined {
+  const impl = env.fns.get(name);
+  if (!impl) return undefined;
+  return absFunction(impl.params, {
+    body: impl.body,
+    async: impl.async,
+    env,
+  });
+}
+
+function lookupExport(env: AstEnv, name: string): Abs | undefined {
+  if (env.vars.has(name)) return env.vars.get(name);
+  return fnToAbs(env, name);
+}
+
+/**
+ * 从已求值 env + AST 收集 ESM 导出。
+ * 支持：export function/const、export { a, b as c }、export default（具名）、
+ * 以及带 source 的 re-export（`export { a } from "mod"` / `export * from "mod"`——
+ * 需 host 传入已求值 modules）。
+ */
+export function collectAbsExports(
+  file: File,
+  env: AstEnv,
+  modules?: Record<string, AbsModuleExports>,
+): AbsModuleExports {
+  const named: Record<string, Abs> = {};
+  let defaultExport: Abs | undefined;
+
+  for (const stmt of file.program.body) {
+    if (stmt.type === "ExportNamedDeclaration") {
+      // re-export：`export { a, b as c } from "mod"`
+      if (stmt.source && modules) {
+        const mod = modules[stmt.source.value];
+        if (mod) {
+          for (const spec of stmt.specifiers) {
+            if (spec.type !== "ExportSpecifier") continue;
+            const local = spec.local.name;
+            const exported =
+              spec.exported.type === "Identifier" ? spec.exported.name : String(spec.exported);
+            const v = local === "default" ? mod.default : mod.named[local];
+            if (v === undefined) continue;
+            if (exported === "default") defaultExport = v;
+            else named[exported] = v;
+          }
+        }
+        continue;
+      }
+      const decl = stmt.declaration;
+      if (decl) {
+        if (decl.type === "FunctionDeclaration" && decl.id) {
+          const v = lookupExport(env, decl.id.name);
+          if (v) named[decl.id.name] = v;
+        } else if (decl.type === "ClassDeclaration" && decl.id) {
+          const v = lookupExport(env, decl.id.name);
+          if (v) named[decl.id.name] = v;
+        } else if (decl.type === "VariableDeclaration") {
+          for (const d of decl.declarations) {
+            if (d.id.type === "Identifier") {
+              const v = lookupExport(env, d.id.name);
+              if (v) named[d.id.name] = v;
+            }
+          }
+        }
+      }
+      for (const spec of stmt.specifiers) {
+        if (spec.type !== "ExportSpecifier") continue;
+        const local = spec.local.name;
+        const exported =
+          spec.exported.type === "Identifier" ? spec.exported.name : String(spec.exported);
+        const v = lookupExport(env, local);
+        if (v) named[exported] = v;
+      }
+    } else if (stmt.type === "ExportAllDeclaration" && stmt.source && modules) {
+      // export * from "mod"：并入 named（不含 default，与 ESM 一致）
+      const mod = modules[stmt.source.value];
+      if (mod?.named) {
+        for (const [k, v] of Object.entries(mod.named)) named[k] = v;
+      }
+    } else if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      if (d.type === "FunctionDeclaration") {
+        defaultExport = lookupExport(env, d.id ? d.id.name : "default");
+      } else if (d.type === "ClassDeclaration" && d.id) {
+        defaultExport = lookupExport(env, d.id.name);
+      } else if (d.type === "Identifier") {
+        defaultExport = lookupExport(env, d.name);
+      }
+    }
+  }
+
+  const result: AbsModuleExports = { named };
+  if (defaultExport) result.default = defaultExport;
+  return result;
+}

package/src/algebra/abs.ts

@@ -0,0 +1,206 @@
+/** 抽象值 Abs = 形状 × 项 × 约束 × 置信度 */
+
+import type { Term, LiteralValue } from "./term.ts";
+import { lit, simplifyTerm, termEquals, termToString } from "./term.ts";
+import type { Pred, PrimName } from "./pred.ts";
+import {
+  and,
+  predToString,
+  pTrue,
+  ptypeof,
+  implies,
+  type Phi,
+} from "./pred.ts";
+
+export type Confidence = "exact" | "path" | "widened" | "mock" | "partial" | "opaque";
+
+export type Shape =
+  | { k: "never" }
+  /**
+   * any：JS 里可以是任意值（无约束参数）。
+   * 运算按真实 JS 语义取并集，不是「分析失败」。
+   */
+  | { k: "any" }
+  /** unknown：分析拿不到信息（求值失败/泄漏），不是「任意值」 */
+  | { k: "unknown" }
+  | { k: "prim"; type: PrimName }
+  | {
+      k: "obj";
+      slots: Record<string, { value: Abs; optional?: boolean; readonly?: boolean }>;
+      index?: { key: Abs; value: Abs };
+      open?: boolean;
+    }
+  | { k: "arr"; element: Abs }
+  | { k: "tuple"; elements: Abs[]; rest?: Abs }
+  | { k: "fn"; params: string[]; name?: string; paramTypes?: Abs[]; returnType?: Abs }
+  | { k: "brand"; name: string; shape: Abs }
+  | { k: "eff"; eff: "promise" | "generator"; inner: Abs }
+  | { k: "sum"; members: Abs[] };
+
+export type Abs = {
+  shape: Shape;
+  term?: Term;
+  pred?: Pred;
+  conf: Confidence;
+};
+
+// --- 工厂 ---
+
+export const never: Abs = { shape: { k: "never" }, conf: "exact" };
+/** 分析无信息 */
+export const unknown: Abs = { shape: { k: "unknown" }, conf: "partial" };
+
+/** 带 term 的 any（generalize type-var） */
+export function anyVar(id: string, conf: Confidence = "path"): Abs {
+  return { shape: { k: "any" }, term: { op: "var", id }, conf };
+}
+
+export function num(): Abs {
+  return { shape: { k: "prim", type: "number" }, conf: "exact" };
+}
+
+export function str(): Abs {
+  return { shape: { k: "prim", type: "string" }, conf: "exact" };
+}
+
+export function bool(): Abs {
+  return { shape: { k: "prim", type: "boolean" }, conf: "exact" };
+}
+
+export function numLit(value: number): Abs {
+  return {
+    shape: { k: "prim", type: "number" },
+    term: lit(value),
+    pred: pTrue,
+    conf: "exact",
+  };
+}
+
+export function strLit(value: string): Abs {
+  return {
+    shape: { k: "prim", type: "string" },
+    term: lit(value),
+    pred: pTrue,
+    conf: "exact",
+  };
+}
+
+export function boolLit(value: boolean): Abs {
+  return {
+    shape: { k: "prim", type: "boolean" },
+    term: lit(value),
+    pred: pTrue,
+    conf: "exact",
+  };
+}
+
+/** 带项的符号数，例如参数 x */
+export function numVar(id: string, pred?: Pred, conf: Confidence = "path"): Abs {
+  return {
+    shape: { k: "prim", type: "number" },
+    term: { op: "var", id },
+    pred: pred ?? pTrue,
+    conf,
+  };
+}
+
+export function obj(
+  slots: Record<string, { value: Abs; optional?: boolean }>,
+): Abs {
+  return { shape: { k: "obj", slots }, conf: "exact" };
+}
+
+export function confJoin(a: Confidence, b: Confidence): Confidence {
+  const rank: Confidence[] = ["exact", "path", "widened", "mock", "partial", "opaque"];
+  const ia = rank.indexOf(a);
+  const ib = rank.indexOf(b);
+  // 取更差的
+  return rank[Math.max(ia < 0 ? 5 : ia, ib < 0 ? 5 : ib)]!;
+}
+
+export function absToString(a: Abs): string {
+  const parts: string[] = [shapeToString(a.shape)];
+  if (a.term) parts.push(`term=${termToString(a.term)}`);
+  if (a.pred && a.pred.op !== "true") parts.push(predToString(a.pred));
+  parts.push(`#${a.conf}`);
+  return parts.join(" ");
+}
+
+export function shapeToString(s: Shape): string {
+  switch (s.k) {
+    case "never":
+      return "never";
+    case "any":
+      return "any";
+    case "unknown":
+      return "unknown";
+    case "prim":
+      return s.type;
+    case "obj": {
+      const entries = Object.entries(s.slots).map(
+        ([k, slot]) =>
+          `${k}${slot.optional ? "?" : ""}: ${absToString(slot.value)}`,
+      );
+      return `{ ${entries.join(", ")} }`;
+    }
+    case "arr":
+      return `${shapeToString(s.element.shape)}[]`;
+    case "tuple":
+      return `[${s.elements.map((e) => shapeToString(e.shape)).join(", ")}]`;
+    case "fn":
+      return `fn(${s.params.join(", ")})${s.name ? ` ${s.name}` : ""}`;
+    case "brand":
+      return s.name;
+    case "eff":
+      return `${s.eff}<${shapeToString(s.inner.shape)}>`;
+    case "sum":
+      return s.members.map(absToString).join(" | ");
+    default:
+      return "·";
+  }
+}
+
+/** 从 term 反推 prim shape */
+export function shapeOfTerm(t: Term): Shape {
+  if (t.op === "lit") {
+    const v = t.value;
+    if (typeof v === "number") return { k: "prim", type: "number" };
+    if (typeof v === "string") return { k: "prim", type: "string" };
+    if (typeof v === "boolean") return { k: "prim", type: "boolean" };
+    if (typeof v === "bigint") return { k: "prim", type: "bigint" };
+    return { k: "unknown" };
+  }
+  return { k: "unknown" };
+}
+
+/** 构造带项的结果 Abs；pred 相对 term */
+export function abs(
+  shape: Shape,
+  term: Term | undefined,
+  pred: Pred | undefined,
+  conf: Confidence,
+): Abs {
+  return {
+    shape,
+    term,
+    pred: pred && pred.op !== "true" ? pred : undefined,
+    conf,
+  };
+}
+
+export function isNumPrim(a: Abs): boolean {
+  return a.shape.k === "prim" && a.shape.type === "number";
+}
+
+export function isStrPrim(a: Abs): boolean {
+  return a.shape.k === "prim" && a.shape.type === "string";
+}
+
+/** 置信度：字面量全确定 */
+export function isExactLit(a: Abs): boolean {
+  return a.conf === "exact" && a.term?.op === "lit";
+}
+
+export function litValue(a: Abs): LiteralValue | undefined {
+  return a.term?.op === "lit" ? a.term.value : undefined;
+}