@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/leq.ts

@@ -1,301 +0,0 @@
-/**
- * 结构可赋值：src ≤ tgt（Abs 上的 leq）。
- *
- * 规则与 TS 结构子类型同构，但作用在推断出的 Abs 上：
- * - 对象宽度 + 深度；optional 可缺
- * - brand 名义；fn 参数逆变、返回协变
- * - pred：src 蕴含 tgt（更严的值可赋给更宽的目标）
- *
- * 不是完备 checker 的替代——是 Abs 之间的兼容判定。
- */
-
-import type { Abs, Shape } from "./abs.ts";
-import { litValue } from "./abs.ts";
-import type { Phi, Pred } from "./pred.ts";
-import { pTrue, implies } from "./pred.ts";
-import { termEquals } from "./term.ts";
-import type { AstEnv } from "./ast-eval.ts";
-import { getClassChain } from "./language.ts";
-
-export type LeqResult = {
-  ok: boolean;
-  /** Nudo 式原因（actual ⊭ target），不是 TS 文案 */
-  reason?: string;
-};
-
-function ok(): LeqResult {
-  return { ok: true };
-}
-
-function fail(reason: string): LeqResult {
-  return { ok: false, reason };
-}
-
-/**
- * src 可赋给 tgt。
- * phi：路径前提（可选）；env：用于 brand 继承链。
- */
-export function leqAbs(
-  src: Abs,
-  tgt: Abs,
-  opts: { phi?: Phi; env?: AstEnv } = {},
-): LeqResult {
-  const phi = opts.phi ?? pTrue;
-  return leqWithPred(src, tgt, phi, opts.env ?? null, 0);
-}
-
-function leqWithPred(
-  src: Abs,
-  tgt: Abs,
-  phi: Phi,
-  env: AstEnv | null,
-  depth: number,
-): LeqResult {
-  if (depth > 32) return fail("leq depth exceeded");
-
-  // never ≤ 任意
-  if (src.shape.k === "never") return ok();
-  // 任意 ≤ any / unknown（目标放宽）
-  if (tgt.shape.k === "any" || tgt.shape.k === "unknown") return ok();
-  // any ≤ 任意（源是任意值，目标收窄时不在此判定失败——由 pred/slot 再卡）
-  if (src.shape.k === "any") return ok();
-
-  // 字面量：先按 lit 值裁定，再走 shape
-  const sv = litValue(src);
-  const tv = litValue(tgt);
-  if (sv !== undefined && tv !== undefined) {
-    if (sv === tv) return ok();
-    // 数值字面量可进带 pred 的 number（走 pred 蕴含）
-  }
-
-  const shapeR = leqShape(src, tgt, phi, env, depth);
-  if (!shapeR.ok) return shapeR;
-
-  // shape 兼容后检查 pred：src.pred ∧ phi ⇒ tgt.pred
-  return leqPred(src, tgt, phi, depth);
-}
-
-function leqPred(src: Abs, tgt: Abs, phi: Phi, depth: number): LeqResult {
-  const sp = src.pred && src.pred.op !== "true" ? src.pred : undefined;
-  const tp = tgt.pred && tgt.pred.op !== "true" ? tgt.pred : undefined;
-  if (!tp) return ok(); // 目标无约束
-  if (!sp) {
-    // 源无约束但目标有：数值界用 bounds 粗判；否则不蕴含
-    // 保守：仅当目标 pred 在 phi 下已被蕴含才 ok
-    if (implies(phi, tp)) return ok();
-    return fail(`pred ⊭ ${predBrief(tp)}`);
-  }
-  const combined: Phi =
-    phi.op === "true" ? sp : { op: "and", args: [phi, sp] };
-  if (implies(combined, tp)) return ok();
-  // 数值界：src 更严可赋给更宽目标（x>5 ≤ x>0）
-  if (numericBoundsImply(sp, tp)) return ok();
-  return fail(`pred ⊭ ${predBrief(tp)}`);
-}
-
-function predBrief(p: Pred): string {
-  switch (p.op) {
-    case "gt":
-    case "ge":
-    case "lt":
-    case "le":
-    case "eq":
-    case "ne":
-      return p.op;
-    default:
-      return p.op;
-  }
-}
-
-/** 数值界蕴含：src 的界更紧则可赋给更宽 tgt */
-function numericBoundsImply(src: Pred, tgt: Pred): boolean {
-  // 单比较：x > n_src ⇒ x > n_tgt 当 n_src ≥ n_tgt（gt）；对称处理 ge
-  const one = (p: Pred): p is Extract<Pred, { op: "gt" | "ge" | "lt" | "le" }> =>
-    p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le";
-  if (!one(src) || !one(tgt)) return false;
-  if (src.op !== tgt.op) {
-    // gt ⇒ ge；lt ⇒ le
-    if (src.op === "gt" && tgt.op === "ge") {
-      return sameTermSide(src, tgt) && litGE(src.b, tgt.b);
-    }
-    if (src.op === "lt" && tgt.op === "le") {
-      return sameTermSide(src, tgt) && litLE(src.b, tgt.b);
-    }
-    return false;
-  }
-  if (!sameTermSide(src, tgt)) return false;
-  const sb = src.b.op === "lit" ? src.b.value : undefined;
-  const tb = tgt.b.op === "lit" ? tgt.b.value : undefined;
-  if (typeof sb !== "number" || typeof tb !== "number") return false;
-  if (src.op === "gt" || src.op === "ge") {
-    return sb >= tb; // 更大的下界 ⇒ 更小的下界
-  }
-  return sb <= tb; // 更小的上界 ⇒ 更大的上界
-}
-
-function sameTermSide(
-  a: { a: { op: string }; b: { op: string } },
-  b: { a: { op: string }; b: { op: string } },
-): boolean {
-  // termEquals 走结构比较，避免 sum×sum 场景 JSON.stringify 爆炸
-  return a.a.op === b.a.op && termEquals(a.a as never, b.a as never);
-}
-
-function litGE(
-  a: { op: string; value?: unknown },
-  b: { op: string; value?: unknown },
-): boolean {
-  if (a.op !== "lit" || b.op !== "lit") return false;
-  return typeof a.value === "number" && typeof b.value === "number" && a.value >= b.value;
-}
-
-function litLE(
-  a: { op: string; value?: unknown },
-  b: { op: string; value?: unknown },
-): boolean {
-  if (a.op !== "lit" || b.op !== "lit") return false;
-  return typeof a.value === "number" && typeof b.value === "number" && a.value <= b.value;
-}
-
-function leqShape(
-  src: Abs,
-  tgt: Abs,
-  phi: Phi,
-  env: AstEnv | null,
-  depth: number,
-): LeqResult {
-  const s = src.shape;
-  const t = tgt.shape;
-
-  // sum 源：每个成员 ≤ tgt
-  if (s.k === "sum") {
-    for (const m of s.members) {
-      const r = leqWithPred(m, tgt, phi, env, depth + 1);
-      if (!r.ok) return fail(`sum member: ${r.reason}`);
-    }
-    return ok();
-  }
-  // sum 目标：src ≤ 某个成员
-  if (t.k === "sum") {
-    for (const m of t.members) {
-      if (leqWithPred(src, m, phi, env, depth + 1).ok) return ok();
-    }
-    return fail("src ⊭ sum");
-  }
-
-  // prim：同型；lit 归入对应 prim
-  if (t.k === "prim") {
-    const sp = primOf(src);
-    if (!sp) return fail(`shape ${s.k} ⊭ prim ${t.type}`);
-    if (sp !== t.type) return fail(`prim ${sp} ⊭ prim ${t.type}`);
-    return ok();
-  }
-
-  // 对象：宽度 + 深度
-  if (t.k === "obj") {
-    if (s.k !== "obj" && s.k !== "brand") {
-      return fail(`shape ${s.k} ⊭ obj`);
-    }
-    const srcObj =
-      s.k === "obj"
-        ? s
-        : s.k === "brand"
-          ? (s.shape.shape.k === "obj" ? s.shape.shape : null)
-          : null;
-    if (!srcObj || srcObj.k !== "obj") return fail(`shape ${s.k} ⊭ obj`);
-    for (const [key, slot] of Object.entries(t.slots)) {
-      const srcSlot = srcObj.slots[key];
-      if (!srcSlot) {
-        if (slot.optional) continue;
-        return fail(`missing slot ${key}`);
-      }
-      if (srcSlot.optional && !slot.optional) {
-        return fail(`slot ${key}: optional ⊭ required`);
-      }
-      const r = leqWithPred(srcSlot.value, slot.value, phi, env, depth + 1);
-      if (!r.ok) return fail(`slot ${key}: ${r.reason}`);
-    }
-    return ok();
-  }
-
-  // 数组
-  if (t.k === "arr") {
-    if (s.k === "arr") {
-      return leqWithPred(s.element, t.element, phi, env, depth + 1);
-    }
-    if (s.k === "tuple") {
-      return s.elements.every((el) => leqWithPred(el, t.element, phi, env, depth + 1).ok)
-        ? ok()
-        : fail("tuple ⊭ arr");
-    }
-    return fail(`shape ${s.k} ⊭ arr`);
-  }
-
-  // 元组
-  if (t.k === "tuple") {
-    if (s.k !== "tuple") return fail(`shape ${s.k} ⊭ tuple`);
-    if (s.elements.length !== t.elements.length) {
-      return fail(`tuple arity ${s.elements.length} ⊭ ${t.elements.length}`);
-    }
-    for (let i = 0; i < t.elements.length; i++) {
-      const r = leqWithPred(s.elements[i]!, t.elements[i]!, phi, env, depth + 1);
-      if (!r.ok) return fail(`tuple[${i}]: ${r.reason}`);
-    }
-    return ok();
-  }
-
-  // 函数：参数逆变、返回协变
-  if (t.k === "fn") {
-    if (s.k !== "fn") return fail(`shape ${s.k} ⊭ fn`);
-    if (s.params.length !== t.params.length) {
-      return fail(`fn arity ${s.params.length} ⊭ ${t.params.length}`);
-    }
-    if (t.returnType !== undefined) {
-      const sr = s.returnType;
-      if (!sr) return fail("fn return unknown ⊭ target return");
-      const r = leqWithPred(sr, t.returnType, phi, env, depth + 1);
-      if (!r.ok) return fail(`fn return: ${r.reason}`);
-    }
-    // 参数：tgt 参数 ≤ src 参数（逆变）—— 有 paramTypes 时检查
-    if (s.paramTypes && t.paramTypes) {
-      for (let i = 0; i < t.paramTypes.length; i++) {
-        const sp = s.paramTypes[i];
-        const tp = t.paramTypes[i];
-        if (!sp || !tp) continue;
-        const r = leqWithPred(tp, sp, phi, env, depth + 1);
-        if (!r.ok) return fail(`fn param[${i}]: ${r.reason}`);
-      }
-    }
-    return ok();
-  }
-
-  // brand：名义（同名或继承链）
-  if (t.k === "brand") {
-    if (s.k !== "brand") return fail(`shape ${s.k} ⊭ brand ${t.name}`);
-    if (s.name === t.name) return ok();
-    if (env) {
-      const chain = getClassChain(env, s.name).map((c) => c.name);
-      if (chain.includes(t.name)) return ok();
-    }
-    return fail(`brand ${s.name} ⊭ brand ${t.name}`);
-  }
-
-  // eff
-  if (t.k === "eff") {
-    if (s.k !== "eff" || s.eff !== t.eff) return fail(`shape ${s.k} ⊭ eff ${t.eff}`);
-    return leqWithPred(s.inner, t.inner, phi, env, depth + 1);
-  }
-
-  if (s.k === t.k) return ok();
-  return fail(`shape ${s.k} ⊭ ${t.k}`);
-}
-
-function primOf(a: Abs): "number" | "string" | "boolean" | "bigint" | "symbol" | undefined {
-  if (a.shape.k === "prim") return a.shape.type;
-  const lv = litValue(a);
-  if (typeof lv === "number") return "number";
-  if (typeof lv === "string") return "string";
-  if (typeof lv === "boolean") return "boolean";
-  if (typeof lv === "bigint") return "bigint";
-  return undefined;
-}

package/src/algebra/load-deps-fp.ts

@@ -1,97 +0,0 @@
-/**
- * loadModule 可达依赖的内容指纹（check 整文件 memo + generalize L0 共用）。
- * 覆盖 @nudo:import / ESM from / require / dynamic import；对每条 spec 做
- * 传递 BFS（seen 防环），直到节点上限。截断时 truncated=true——调用方必须
- * fail-open（不得写入/读取 memo）。
- */
-import { extractNudoImports } from "./refine.ts";
-import { hashSource } from "./hash-source.ts";
-
-export type LoadDepsFingerprint = {
-  fp: string;
-  paths: string[];
-  /** BFS 撞到节点上限：剩余 dep 未进指纹，键不可信 */
-  truncated: boolean;
-};
-
-/** 防病态图；seen 已防环，此上限只限制遍历量 */
-const MAX_LOAD_DEP_NODES = 64;
-
-export function normPath(p: string): string {
-  return p.replace(/\\/g, "/");
-}
-
-/** core 不引 path：相对 spec 纯字符串拼接（与 LSP resolve 对齐时双方 norm） */
-export function resolveDepPath(fromFile: string, spec: string): string {
-  const s = normPath(spec);
-  if (!s.startsWith(".")) return s;
-  const from = normPath(fromFile);
-  const i = from.lastIndexOf("/");
-  const base = i >= 0 ? from.slice(0, i) : "";
-  const parts = base ? base.split("/") : [];
-  for (const seg of s.split("/")) {
-    if (seg === "" || seg === ".") continue;
-    if (seg === "..") parts.pop();
-    else parts.push(seg);
-  }
-  return parts.join("/");
-}
-
-/**
- * All string module specs that analysis may resolve through loadModule.
- * Regex over-approximates (may hit comments) — extra dep fingerprint is safe
- * (more misses, never a stale hit).
- */
-export function extractAllLoadSpecs(source: string): string[] {
-  const specs = new Set<string>();
-  for (const imp of extractNudoImports(source)) specs.add(imp.spec);
-  const patterns = [
-    /\bfrom\s*['"]([^'"]+)['"]/g,
-    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-  ];
-  for (const re of patterns) {
-    let m: RegExpExecArray | null;
-    while ((m = re.exec(source))) specs.add(m[1]!);
-  }
-  return [...specs];
-}
-
-/**
- * Fingerprint every loadModule-reachable dep (not only `*.nudo.js`), including
- * one hop of transitive specs from each dep source.
- */
-export function loadModuleDepsFingerprint(
-  source: string,
-  loadModule: (spec: string, fromFile: string) => string | undefined,
-  fromFile: string,
-): LoadDepsFingerprint {
-  const parts: string[] = [];
-  const paths: string[] = [];
-  const seen = new Set<string>();
-  const queue: Array<{ spec: string; from: string }> = extractAllLoadSpecs(source).map(
-    (spec) => ({ spec, from: fromFile }),
-  );
-  let n = 0;
-  while (queue.length > 0) {
-    if (n >= MAX_LOAD_DEP_NODES) {
-      parts.sort();
-      return { fp: `trunc:${parts.join(",")}`, paths, truncated: true };
-    }
-    const cur = queue.shift()!;
-    const path = resolveDepPath(cur.from, cur.spec);
-    if (seen.has(path)) continue;
-    seen.add(path);
-    n++;
-    const src = loadModule(cur.spec, cur.from);
-    parts.push(`${path}=${src === undefined ? "miss" : hashSource(src)}`);
-    paths.push(path);
-    if (src === undefined) continue;
-    for (const next of extractAllLoadSpecs(src)) {
-      const nextPath = resolveDepPath(path, next);
-      if (!seen.has(nextPath)) queue.push({ spec: next, from: path });
-    }
-  }
-  parts.sort();
-  return { fp: parts.join(","), paths, truncated: false };
-}

package/src/algebra/methods.ts

@@ -1,128 +0,0 @@
-/**
- * Abs 方法表：模板字符串 / 结构值上的方法与属性。
- * 类型即计算——方法结果仍是 Abs，可继续参与约束推理。
- * 宿主 TypeValue 的 dispatchMethod 只服务 IR 兜底，不是真理源。
- */
-
-import type { Abs } from "./abs.ts";
-import { abs, litValue, numLit, strLit, boolLit } from "./abs.ts";
-import {
-  isTemplateLike,
-  templatePartsOf,
-  concatString,
-} from "./template.ts";
-
-function strPrim(conf: Abs["conf"] = "path"): Abs {
-  return abs({ k: "prim", type: "string" }, undefined, undefined, conf);
-}
-
-function boolPrim(): Abs {
-  return abs({ k: "prim", type: "boolean" }, undefined, undefined, "partial");
-}
-
-function knownPrefix(parts: Abs[]): string {
-  let s = "";
-  for (const p of parts) {
-    if (p.term?.op === "lit" && typeof p.term.value === "string") s += p.term.value;
-    else break;
-  }
-  return s;
-}
-
-function knownSuffix(parts: Abs[]): string {
-  let s = "";
-  for (let i = parts.length - 1; i >= 0; i--) {
-    const p = parts[i]!;
-    if (p.term?.op === "lit" && typeof p.term.value === "string") s = p.term.value + s;
-    else break;
-  }
-  return s;
-}
-
-function fixedLength(parts: Abs[]): number | undefined {
-  if (parts.some((p) => !(p.term?.op === "lit" && typeof p.term.value === "string"))) {
-    return undefined;
-  }
-  return parts.reduce((n, p) => n + String(p.term && p.term.op === "lit" ? p.term.value : "").length, 0);
-}
-
-/**
- * 调用 Abs 方法。返回 undefined = 未接管（调用方走其它路径）。
- */
-export function callAbsMethod(
-  recv: Abs,
-  name: string,
-  args: Abs[],
-): Abs | undefined {
-  // 模板 / 字符串
-  if (isTemplateLike(recv) || (recv.shape.k === "prim" && recv.shape.type === "string")) {
-    const a0 = args[0] ? litValue(args[0]) : undefined;
-    if (isTemplateLike(recv)) {
-      const parts = templatePartsOf(recv);
-      const prefix = knownPrefix(parts);
-      const suffix = knownSuffix(parts);
-      switch (name) {
-        case "startsWith": {
-          if (typeof a0 !== "string") return boolPrim();
-          if (prefix.length >= a0.length) return boolLit(prefix.startsWith(a0));
-          if (a0.startsWith(prefix)) return boolPrim();
-          return boolLit(false);
-        }
-        case "endsWith": {
-          if (typeof a0 !== "string") return boolPrim();
-          if (suffix.length >= a0.length) return boolLit(suffix.endsWith(a0));
-          if (a0.endsWith(suffix)) return boolPrim();
-          return boolLit(false);
-        }
-        case "includes": {
-          if (typeof a0 !== "string") return boolPrim();
-          const fixed = parts
-            .filter((p) => p.term?.op === "lit" && typeof p.term.value === "string")
-            .map((p) => String(p.term && p.term.op === "lit" ? p.term.value : ""))
-            .join("");
-          if (fixed.includes(a0)) return boolLit(true);
-          return boolPrim();
-        }
-        case "toUpperCase":
-        case "toLowerCase":
-        case "trim":
-          return strPrim("path");
-        case "slice":
-          return strPrim("path");
-        case "concat": {
-          let acc = recv;
-          for (const a of args) acc = concatString(acc, a);
-          return acc;
-        }
-        case "toString":
-        case "valueOf":
-          return recv;
-      }
-    }
-  }
-
-  // 数组 / 元组 join 等已在 ast-eval；此处只补模板
-  return undefined;
-}
-
-/** 属性读取：template.length 等 */
-export function getAbsProperty(recv: Abs, name: string): Abs | undefined {
-  if (name === "length") {
-    if (isTemplateLike(recv)) {
-      const parts = templatePartsOf(recv);
-      const n = fixedLength(parts);
-      if (n !== undefined) return numLit(n);
-      // 有抽象部件：下界 = 固定前缀+后缀长度
-      const min = parts
-        .filter((p) => p.term?.op === "lit" && typeof p.term.value === "string")
-        .reduce((s, p) => s + String(p.term && p.term.op === "lit" ? p.term.value : "").length, 0);
-      return abs(
-        { k: "prim", type: "number" },
-        undefined,
-        undefined,
-        "path",
-      );
-    }
-  }
-  return undefined;
-}