@nudojs/core 0.3.0 → 0.4.0

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

@@ -1,41 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,139 +0,0 @@
-/**
- * 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

@@ -1,206 +0,0 @@
-/** 抽象值 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;
-}