@nudojs/cli 0.2.0 → 0.3.0

package/src/narrowing.ts

@@ -9,7 +9,9 @@ import {
   typeValueEquals,
   isSubtypeOf,
   createRange,
+  v as termVar,
 } from "@nudojs/core";
+import { attachTerm } from "./term-registry.ts";
 
 /**
  * Given a test expression and the current environment, produce two
@@ -19,6 +21,20 @@ export function narrow(
   test: Node,
   env: Environment,
 ): [trueEnv: Environment, falseEnv: Environment] {
+  // a || b：fallthrough（both-false）是链式交集 —— narrow(a) 的 false
+  // env 再 narrow(b) 的 false。这是 `if (typeof x !== 'object' || x === null)
+  // return x;` 守卫模式的关键：后续代码里 x 只剩 object 成员。true 侧
+  // 环境无法并集合并，保守退回未 narrow 的 env。
+  // a && b 对称：true 侧链式（both-true），false 侧保守。
+  if (test.type === "LogicalExpression" && (test.operator === "||" || test.operator === "&&")) {
+    const [trueOfLeft, falseOfLeft] = narrow(test.left, env);
+    const [, falseOfBoth] = narrow(test.right, falseOfLeft);
+    const [trueOfBoth] = narrow(test.right, trueOfLeft);
+    return test.operator === "||"
+      ? [env, falseOfBoth]
+      : [trueOfBoth, env];
+  }
+
   // typeof x === "string"
   if (
     test.type === "BinaryExpression" &&
@@ -26,9 +42,9 @@ export function narrow(
     isTypeofExpr(test.left) &&
     test.right.type === "StringLiteral"
   ) {
-    const varName = getTypeofTarget(test.left);
-    if (varName) {
-      return narrowByTypeof(varName, test.right.value, env);
+    const target = getTypeofTarget(test.left);
+    if (target) {
+      return target ? narrowByTypeof(target, test.right.value, env) : [env, env];
     }
   }
 
@@ -39,9 +55,9 @@ export function narrow(
     test.left.type === "StringLiteral" &&
     isTypeofExpr(test.right)
   ) {
-    const varName = getTypeofTarget(test.right);
-    if (varName) {
-      return narrowByTypeof(varName, test.left.value, env);
+    const target = getTypeofTarget(test.right);
+    if (target) {
+      return target ? narrowByTypeof(target, test.left.value, env) : [env, env];
     }
   }
 
@@ -52,9 +68,9 @@ export function narrow(
     isTypeofExpr(test.left) &&
     test.right.type === "StringLiteral"
   ) {
-    const varName = getTypeofTarget(test.left);
-    if (varName) {
-      const [trueEnv, falseEnv] = narrowByTypeof(varName, test.right.value, env);
+    const target = getTypeofTarget(test.left);
+    if (target) {
+      const [trueEnv, falseEnv] = target ? narrowByTypeof(target, test.right.value, env) : [env, env];
       return [falseEnv, trueEnv];
     }
   }
@@ -66,13 +82,50 @@ export function narrow(
     test.left.type === "StringLiteral" &&
     isTypeofExpr(test.right)
   ) {
-    const varName = getTypeofTarget(test.right);
-    if (varName) {
-      const [trueEnv, falseEnv] = narrowByTypeof(varName, test.left.value, env);
+    const target = getTypeofTarget(test.right);
+    if (target) {
+      const [trueEnv, falseEnv] = narrowByTypeof(target, test.left.value, env);
       return [falseEnv, trueEnv];
     }
   }
 
+  // obj.prop === literal (discriminated union)
+  if (
+    test.type === "BinaryExpression" &&
+    test.operator === "===" &&
+    test.left.type === "MemberExpression" &&
+    test.left.object.type === "Identifier" &&
+    test.left.property.type === "Identifier" &&
+    isLiteralNode(test.right)
+  ) {
+    return narrowByDiscriminant(test.left.object.name, test.left.property.name, getLiteralValue(test.right), env);
+  }
+
+  // literal === obj.prop
+  if (
+    test.type === "BinaryExpression" &&
+    test.operator === "===" &&
+    isLiteralNode(test.left) &&
+    test.right.type === "MemberExpression" &&
+    test.right.object.type === "Identifier" &&
+    test.right.property.type === "Identifier"
+  ) {
+    return narrowByDiscriminant(test.right.object.name, test.right.property.name, getLiteralValue(test.left), env);
+  }
+
+  // obj.prop !== literal
+  if (
+    test.type === "BinaryExpression" &&
+    test.operator === "!==" &&
+    test.left.type === "MemberExpression" &&
+    test.left.object.type === "Identifier" &&
+    test.left.property.type === "Identifier" &&
+    isLiteralNode(test.right)
+  ) {
+    const [trueEnv, falseEnv] = narrowByDiscriminant(test.left.object.name, test.left.property.name, getLiteralValue(test.right), env);
+    return [falseEnv, trueEnv];
+  }
+
   // x === literal
   if (
     test.type === "BinaryExpression" &&
@@ -152,12 +205,41 @@ export function narrow(
     }
   }
 
+  // "key" in obj
+  if (
+    test.type === "BinaryExpression" &&
+    test.operator === "in" &&
+    test.left.type === "StringLiteral" &&
+    test.right.type === "Identifier"
+  ) {
+    return narrowByPropertyIn(test.left.value, test.right.name, env);
+  }
+
+  // Array.isArray(x)
+  if (
+    test.type === "CallExpression" &&
+    test.callee.type === "MemberExpression" &&
+    test.callee.object.type === "Identifier" &&
+    test.callee.object.name === "Array" &&
+    test.callee.property.type === "Identifier" &&
+    test.callee.property.name === "isArray" &&
+    test.arguments.length === 1 &&
+    test.arguments[0].type === "Identifier"
+  ) {
+    return narrowByIsArray(test.arguments[0].name, env);
+  }
+
   // !expr (negate)
   if (test.type === "UnaryExpression" && test.operator === "!") {
     const [trueEnv, falseEnv] = narrow(test.argument, env);
     return [falseEnv, trueEnv];
   }
 
+  // Truthiness narrowing: if (x)
+  if (test.type === "Identifier") {
+    return narrowByTruthy(test.name, env);
+  }
+
   return [env, env];
 }
 
@@ -165,13 +247,24 @@ function isTypeofExpr(node: Node): boolean {
   return node.type === "UnaryExpression" && node.operator === "typeof";
 }
 
-function getTypeofTarget(node: Node): string | null {
+/** typeof 目标：标识符（x）或成员访问链（ref.has / ns.fn） */
+function getTypeofTarget(node: Node): { kind: "ident"; name: string } | { kind: "member"; objName: string; propName: string } | null {
   if (
     node.type === "UnaryExpression" &&
     node.operator === "typeof" &&
     node.argument.type === "Identifier"
   ) {
-    return node.argument.name;
+    return { kind: "ident", name: node.argument.name };
+  }
+  if (
+    node.type === "UnaryExpression" &&
+    node.operator === "typeof" &&
+    node.argument.type === "MemberExpression" &&
+    node.argument.object.type === "Identifier" &&
+    !node.argument.computed &&
+    node.argument.property.type === "Identifier"
+  ) {
+    return { kind: "member", objName: node.argument.object.name, propName: node.argument.property.name };
   }
   return null;
 }
@@ -203,11 +296,56 @@ const typeofToPrimitive: Record<string, TypeValue> = {
   symbol: T.symbol,
 };
 
+/** 内置类实例的原型方法归属（与 evaluator classMethods 表对齐的子集） */
+const INSTANCE_METHOD_OWNERS: Record<string, Set<string>> = {
+  has: new Set(["Set", "Map", "WeakSet", "WeakMap"]),
+  get: new Set(["Map", "WeakMap"]),
+  set: new Set(["Map", "WeakMap", "Set"]),
+  add: new Set(["Set", "WeakSet"]),
+  delete: new Set(["Set", "Map", "WeakSet", "WeakMap"]),
+  clear: new Set(["Set", "Map"]),
+  forEach: new Set(["Set", "Map", "Array"]),
+  size: new Set(["Set", "Map"]),
+  keys: new Set(["Set", "Map"]),
+  values: new Set(["Set", "Map"]),
+  entries: new Set(["Set", "Map"]),
+  test: new Set(["RegExp"]),
+  exec: new Set(["RegExp"]),
+};
+
 function narrowByTypeof(
-  varName: string,
+  target: { kind: "ident"; name: string } | { kind: "member"; objName: string; propName: string },
   typeStr: string,
   env: Environment,
 ): [Environment, Environment] {
+  // 成员目标（typeof ref.has === 'function'）：按对象成员中 prop 的类型
+  // 过滤 union——留下 has 为函数的成员（如 Set），剔除 tuple/{}
+  if (target.kind === "member") {
+    const current = env.lookup(target.objName);
+    if (!current || current.kind !== "union") return [env, env];
+    const propMatches = (m: TypeValue): boolean => {
+      let prop: TypeValue | undefined;
+      if (m.kind === "object") prop = m.properties[target.propName];
+      else if (m.kind === "instance") {
+        // instance 的 properties 不含原型方法：按内置类方法表判断
+        // （Set/Map 的 has 等——与 evaluator 的 classMethods 表保持一致）
+        if (INSTANCE_METHOD_OWNERS[target.propName]?.has(m.className)) return true;
+        prop = m.properties[target.propName];
+      }
+      if (typeStr === "function") return prop?.kind === "function" || prop?.kind === "unknown";
+      return true;
+    };
+    const narrowed = narrowType(current, propMatches);
+    const excluded = subtractType(current, propMatches);
+    if (narrowed.kind === "never") return [env, env];
+    const trueEnv = env.extend({});
+    trueEnv.bind(target.objName, narrowed);
+    const falseEnv = env.extend({});
+    falseEnv.bind(target.objName, excluded.kind === "never" ? current : excluded);
+    return [trueEnv, falseEnv];
+  }
+
+  const varName = target.name;
   const current = env.lookup(varName);
   const targetPrimitive = typeofToPrimitive[typeStr];
 
@@ -316,7 +454,91 @@ function narrowByComparison(
     : op === "<=" ? createRange({ min: value + 1 })
     : createRange({ min: value });
 
+  // 保留项身份：range 界经 toAbsWithTerms 编码为 Pred，代数继续传播
+  const term = termVar(varName);
+  attachTerm(trueRange, term);
+  attachTerm(falseRange, term);
+
   trueEnv.bind(varName, trueRange);
   falseEnv.bind(varName, falseRange);
   return [trueEnv, falseEnv];
 }
+
+function narrowByPropertyIn(propName: string, varName: string, env: Environment): [Environment, Environment] {
+  const current = env.lookup(varName);
+
+  const narrowed = narrowType(current, (m) =>
+    m.kind === "object" && propName in m.properties
+  );
+  const excluded = subtractType(current, (m) =>
+    m.kind === "object" && propName in m.properties
+  );
+
+  const trueEnv = env.extend({});
+  trueEnv.bind(varName, narrowed.kind === "never" ? current : narrowed);
+  const falseEnv = env.extend({});
+  falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
+  return [trueEnv, falseEnv];
+}
+
+function narrowByIsArray(varName: string, env: Environment): [Environment, Environment] {
+  const current = env.lookup(varName);
+
+  const narrowed = narrowType(current, (m) => m.kind === "array" || m.kind === "tuple");
+  const excluded = subtractType(current, (m) => m.kind === "array" || m.kind === "tuple");
+
+  const trueEnv = env.extend({});
+  trueEnv.bind(varName, narrowed.kind === "never" ? T.array(T.unknown) : narrowed);
+  const falseEnv = env.extend({});
+  falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
+  return [trueEnv, falseEnv];
+}
+
+function narrowByDiscriminant(
+  objName: string,
+  propName: string,
+  literalValue: TypeValue,
+  env: Environment,
+): [Environment, Environment] {
+  const current = env.lookup(objName);
+
+  const narrowed = narrowType(current, (m) => {
+    if (m.kind !== "object") return false;
+    const propType = m.properties[propName];
+    if (!propType) return false;
+    return typeValueEquals(propType, literalValue);
+  });
+
+  const excluded = subtractType(current, (m) => {
+    if (m.kind !== "object") return false;
+    const propType = m.properties[propName];
+    if (!propType) return false;
+    return typeValueEquals(propType, literalValue);
+  });
+
+  const trueEnv = env.extend({});
+  trueEnv.bind(objName, narrowed.kind === "never" ? current : narrowed);
+  const falseEnv = env.extend({});
+  falseEnv.bind(objName, excluded.kind === "never" ? current : excluded);
+  return [trueEnv, falseEnv];
+}
+
+function isFalsyType(tv: TypeValue): boolean {
+  if (tv.kind === "literal") {
+    return tv.value === null || tv.value === undefined || tv.value === false || tv.value === 0 || tv.value === "";
+  }
+  return false;
+}
+
+function narrowByTruthy(varName: string, env: Environment): [Environment, Environment] {
+  const current = env.lookup(varName);
+
+  const narrowed = narrowType(current, (m) => !isFalsyType(m));
+  const excluded = subtractType(current, (m) => !isFalsyType(m));
+
+  const trueEnv = env.extend({});
+  trueEnv.bind(varName, narrowed.kind === "never" ? current : narrowed);
+  const falseEnv = env.extend({});
+  falseEnv.bind(varName, excluded.kind === "never" ? current : excluded);
+  return [trueEnv, falseEnv];
+}

package/src/phi-from-test.ts

@@ -0,0 +1,42 @@
+/**
+ * 从 Babel 测试表达式提取代数 Φ 约束。
+ * 支持 `x > n` / `x >= n` / `x < n` / `x <= n`（Identifier × NumericLiteral）。
+ * false 分支用对偶比较（`>` ↔ `≤`），使 else 路径也能携带约束。
+ */
+
+import type { Node } from "@babel/types";
+import type { Phi } from "@nudojs/core";
+import { pTrue, and as phiAnd, gt, ge, lt, le, v as termVar, lit } from "@nudojs/core";
+
+export function phiFromTest(test: Node): { whenTrue: Phi; whenFalse: Phi } {
+  if (test.type !== "BinaryExpression") {
+    return { whenTrue: pTrue, whenFalse: pTrue };
+  }
+  const op = test.operator;
+  const left = test.left;
+  const right = test.right;
+
+  // x ≷ n
+  if (
+    left.type === "Identifier" &&
+    right.type === "NumericLiteral" &&
+    (op === ">" || op === ">=" || op === "<" || op === "<=")
+  ) {
+    const t = termVar(left.name);
+    const n = lit(right.value);
+    const pred =
+      op === ">" ? gt(t, n) : op === ">=" ? ge(t, n) : op === "<" ? lt(t, n) : le(t, n);
+    // 对偶：¬(a≷b) = a≲b（数值全序）
+    const dual =
+      op === ">" ? le(t, n) : op === ">=" ? lt(t, n) : op === "<" ? ge(t, n) : gt(t, n);
+    return { whenTrue: pred, whenFalse: dual };
+  }
+
+  return { whenTrue: pTrue, whenFalse: pTrue };
+}
+
+export function combinePhi(base: Phi, extra: Phi): Phi {
+  if (extra.op === "true") return base;
+  if (base.op === "true") return extra;
+  return phiAnd(base, extra);
+}

package/src/resolve-npm.ts

@@ -0,0 +1,63 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+
+function findNodeModules(startDir: string): string | null {
+  let dir = resolve(startDir);
+  const root = resolve("/");
+
+  while (dir !== root) {
+    const nmPath = join(dir, "node_modules");
+    if (existsSync(nmPath)) return nmPath;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function resolveExportsNudo(exports: unknown, subpath: string): string | null {
+  if (!exports || typeof exports !== "object") return null;
+
+  const entry = (exports as Record<string, unknown>)[subpath];
+  if (!entry) return null;
+
+  if (typeof entry === "object" && entry !== null && "nudo" in entry) {
+    const nudoEntry = (entry as Record<string, unknown>)["nudo"];
+    if (typeof nudoEntry === "string") return nudoEntry;
+  }
+
+  return null;
+}
+
+export function resolveNpmNudo(
+  source: string,
+  fromDir: string,
+): string | null {
+  const isRelative = source.startsWith(".") || source.startsWith("/");
+  if (isRelative) return null;
+
+  const parts = source.startsWith("@")
+    ? source.split("/").slice(0, 2)
+    : source.split("/").slice(0, 1);
+  const pkgName = parts.join("/");
+  const subpath = source.slice(pkgName.length) || ".";
+
+  const nodeModules = findNodeModules(fromDir);
+  if (!nodeModules) return null;
+
+  const pkgJsonPath = join(nodeModules, pkgName, "package.json");
+  if (!existsSync(pkgJsonPath)) return null;
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    const nudoEntry = resolveExportsNudo(pkg.exports, subpath);
+    if (nudoEntry) {
+      const resolved = resolve(dirname(pkgJsonPath), nudoEntry);
+      if (existsSync(resolved)) return resolved;
+    }
+  } catch {
+    // ignore parse errors
+  }
+
+  return null;
+}

package/src/run-test.ts

@@ -0,0 +1,92 @@
+/**
+ * nudo test — @nudo:case 即测试。
+ *
+ * directive case 带 `=> expected` 时，用 isSubtypeOf 校验推断结果；
+ * 失败记 FAIL，进程退出码 1。无期望的 directive case 记 unchecked。
+ */
+
+import { isSubtypeOf, typeValueToString, type TypeValue } from "@nudojs/core";
+import type { AnalysisResult } from "@nudojs/service";
+
+export type CaseTestOutcome = {
+  fn: string;
+  caseName: string;
+  ok: boolean;
+  unchecked: boolean;
+  expected?: string;
+  actual: string;
+};
+
+export type TestReport = {
+  file: string;
+  passed: number;
+  failed: number;
+  unchecked: number;
+  outcomes: CaseTestOutcome[];
+};
+
+export function buildTestReport(file: string, result: AnalysisResult): TestReport {
+  const outcomes: CaseTestOutcome[] = [];
+  for (const fn of result.functions) {
+    for (const c of fn.cases) {
+      if (c.source !== "directive") continue;
+      const actual = typeValueToString(c.result);
+      if (!c.expected) {
+        outcomes.push({
+          fn: fn.name,
+          caseName: c.name,
+          ok: true,
+          unchecked: true,
+          actual,
+        });
+        continue;
+      }
+      const expected = typeValueToString(c.expected as TypeValue);
+      let ok = false;
+      try {
+        ok = isSubtypeOf(c.result, c.expected as TypeValue);
+      } catch {
+        ok = false;
+      }
+      outcomes.push({
+        fn: fn.name,
+        caseName: c.name,
+        ok,
+        unchecked: false,
+        expected,
+        actual,
+      });
+    }
+  }
+  return {
+    file,
+    passed: outcomes.filter((o) => o.ok && !o.unchecked).length,
+    failed: outcomes.filter((o) => !o.ok).length,
+    unchecked: outcomes.filter((o) => o.unchecked).length,
+    outcomes,
+  };
+}
+
+export function formatTestReport(r: TestReport): string {
+  const lines: string[] = [];
+  lines.push(`nudo test  ${r.file}`);
+  if (r.passed + r.failed + r.unchecked === 0) {
+    lines.push("No @nudo:case directives found.");
+    return lines.join("\n");
+  }
+  lines.push(r.failed === 0 ? "PASS" : "FAILED");
+  lines.push(`  ${r.passed} passed · ${r.failed} failed · ${r.unchecked} unchecked`);
+  lines.push("");
+  for (const o of r.outcomes) {
+    if (o.unchecked) {
+      lines.push(`  [unchecked] ${o.fn}  case "${o.caseName}" → ${o.actual}`);
+    } else if (o.ok) {
+      lines.push(`  [ok]   ${o.fn}  case "${o.caseName}" → ${o.actual}`);
+    } else {
+      lines.push(`  [FAIL] ${o.fn}  case "${o.caseName}"`);
+      lines.push(`         expected: ${o.expected}`);
+      lines.push(`         actual:   ${o.actual}`);
+    }
+  }
+  return lines.join("\n");
+}

package/src/term-registry.ts

@@ -0,0 +1,96 @@
+/**
+ * TypeValue 项（term）身份旁路。
+ *
+ * core 的 TypeValue 无 term 字段；用 WeakMap 旁路挂载，零侵入。
+ * 纪律：
+ * - 禁止给共享单例（T.number 等）挂 term——必须先 clone 再 attach
+ * - typeValueToAbs 优先读旁路；无旁路时按 kind 推导
+ */
+
+import type { TypeValue } from "@nudojs/core";
+import { T } from "@nudojs/core";
+import type { Term } from "@nudojs/core";
+import { v as termVar, lit } from "@nudojs/core";
+import type { Pred } from "@nudojs/core";
+
+const termByTv = new WeakMap<object, Term>();
+const predByTv = new WeakMap<object, Pred>();
+
+export function attachTerm(tv: TypeValue, term: Term): void {
+  if (tv && typeof tv === "object") termByTv.set(tv as object, term);
+}
+
+export function getTerm(tv: TypeValue): Term | undefined {
+  if (tv && typeof tv === "object") return termByTv.get(tv as object);
+  return undefined;
+}
+
+export function attachPred(tv: TypeValue, pred: Pred): void {
+  if (tv && typeof tv === "object") predByTv.set(tv as object, pred);
+}
+
+export function getPred(tv: TypeValue): Pred | undefined {
+  if (tv && typeof tv === "object") return predByTv.get(tv as object);
+  return undefined;
+}
+
+/**
+ * 为参数绑定克隆 TypeValue 并挂 term。
+ * - primitive number → clone + var(name)
+ * - literal number → clone + lit(value)（与 kind 推导一致，但显式）
+ * - refined → clone + 尽量挂 base term + pred
+ */
+export function tagParamArg(arg: TypeValue, paramName: string): TypeValue {
+  if (!paramName || paramName.startsWith("...")) return arg;
+  // 函数/实例不 clone：浅拷贝会丢 _signature / 原型表（Promise executor 等）
+  if (arg.kind === "function" || arg.kind === "instance") return arg;
+  const cloned = cloneTypeValue(arg);
+  if (cloned.kind === "primitive" && cloned.type === "number") {
+    attachTerm(cloned, termVar(paramName));
+  } else if (cloned.kind === "literal" && typeof cloned.value === "number") {
+    attachTerm(cloned, lit(cloned.value));
+  } else if (cloned.kind === "refined") {
+    attachTerm(cloned, termVar(paramName));
+  }
+  return cloned;
+}
+
+function cloneTypeValue(tv: TypeValue): TypeValue {
+  switch (tv.kind) {
+    case "literal":
+      return { kind: "literal", value: tv.value };
+    case "primitive":
+      return { kind: "primitive", type: tv.type };
+    case "refined":
+      return { kind: "refined", base: tv.base, refinement: tv.refinement };
+    case "object":
+      return { kind: "object", properties: tv.properties, id: tv.id };
+    case "array":
+      return { kind: "array", element: tv.element };
+    case "tuple":
+      return { kind: "tuple", elements: tv.elements };
+    case "function":
+      return {
+        kind: "function",
+        params: tv.params,
+        body: tv.body,
+        closure: tv.closure,
+      };
+    case "promise":
+      return { kind: "promise", value: tv.value };
+    case "instance":
+      return {
+        kind: "instance",
+        className: tv.className,
+        properties: tv.properties,
+      };
+    case "union":
+      return { kind: "union", members: tv.members };
+    case "never":
+      return { kind: "never" };
+    case "unknown":
+      return { kind: "unknown" };
+    default:
+      return tv;
+  }
+}

package/CHANGELOG.md

@@ -1,29 +0,0 @@
-# nudo
-
-## 0.2.0
-
-### Minor Changes
-
-- 6c38283: docs and ci
-- 9f7f819: fix pkg info
-- c175f71: version
-
-### Patch Changes
-
-- Updated dependencies [6c38283]
-- Updated dependencies [9f7f819]
-- Updated dependencies [c175f71]
-  - @nudojs/core@0.2.0
-  - @nudojs/parser@0.2.0
-
-## 0.1.0
-
-### Minor Changes
-
-- Conceptual design and basic implementation.
-
-### Patch Changes
-
-- Updated dependencies
-  - @nudojs/core@0.1.0
-  - @nudojs/parser@0.1.0