@nudojs/core 0.2.0 → 0.3.0

package/src/type-value.ts

@@ -1,9 +1,24 @@
 import type { Node } from "@babel/types";
 import type { Environment } from "./environment.ts";
+// 注意：isTemplate 必须来自 template-predicates.ts（只含 `import type` 反向边）
+// 而非 template.ts——后者运行时依赖本模块（T、typeValueToString），会构成环。
+import { isTemplate } from "./refinements/template-predicates.ts";
 
-// --- TypeValue discriminated union ---
+// --- 评估 IR：不是类型系统本体，是 Abs 的外延投影格式 ---
 
-export type LiteralValue = string | number | boolean | null | undefined;
+export type LiteralValue = string | number | boolean | bigint | null | undefined;
+
+// `thisVal` is the bound receiver when the signature is invoked as a method
+// or through Function.prototype.call/apply (e.g. Object.prototype.toString
+// brand computation needs it); direct calls leave it undefined.
+export type SigImpl = (args: TypeValue[], thisVal?: TypeValue) => TypeValue | undefined;
+
+export type FunctionSignature = {
+  paramTypes: TypeValue[];
+  returnType: TypeValue;
+  throwsType: TypeValue;
+  impl?: SigImpl;
+};
 
 export type Refinement = {
   name: string;
@@ -83,6 +98,21 @@ export const T = {
     base,
     refinement,
   }),
+  fnSig: (
+    paramTypes: TypeValue[],
+    returnType: TypeValue,
+    throwsType: TypeValue = { kind: "never" },
+    impl?: SigImpl,
+  ): TypeValue => {
+    const dummy = {
+      kind: "function" as const,
+      params: paramTypes.map((_p, i) => `_arg${i}`),
+      body: { type: "BlockStatement", body: [], directives: [] } as unknown as Node,
+      closure: null as unknown as Environment,
+    };
+    (dummy as any)._signature = { paramTypes, returnType, throwsType, impl } satisfies FunctionSignature;
+    return dummy;
+  },
 } as const;
 
 // --- Helpers ---
@@ -112,6 +142,29 @@ export function typeValueEquals(a: TypeValue, b: TypeValue): boolean {
 }
 
 export function simplifyUnion(members: TypeValue[]): TypeValue {
+  // Fast path: empty or single element
+  if (members.length === 0) return T.never;
+  if (members.length === 1) return members[0].kind === "never" ? T.never : members[0];
+
+  // Fast path: two non-union elements, check equality first
+  if (members.length === 2) {
+    const a = members[0];
+    const b = members[1];
+    // Only use fast path if neither is a union (need flattening)
+    if (a.kind !== "union" && b.kind !== "union") {
+      if (a.kind === "never") return b.kind === "never" ? T.never : b;
+      if (b.kind === "never") return a;
+      if (typeValueEquals(a, b)) return a;
+      if (a.kind === "unknown" || b.kind === "unknown") return T.unknown;
+      // 吸收律：字面量被共存的 widening 基类型吸收（3 | number → number）
+      const aBase = absorbablePrimitiveBase(a);
+      if (aBase !== undefined && typeValueEquals(aBase, b)) return b;
+      const bBase = absorbablePrimitiveBase(b);
+      if (bBase !== undefined && typeValueEquals(bBase, a)) return a;
+      return { kind: "union", members: [a, b] };
+    }
+  }
+
   const flat: TypeValue[] = [];
   for (const m of members) {
     if (m.kind === "never") continue;
@@ -129,10 +182,38 @@ export function simplifyUnion(members: TypeValue[]): TypeValue {
     }
   }
 
-  if (deduped.length === 0) return T.never;
-  if (deduped.length === 1) return deduped[0];
-  if (deduped.some((m) => m.kind === "unknown")) return T.unknown;
-  return { kind: "union", members: deduped };
+  // 吸收律：成员中存在某字面量/模板字面量的 widening 基类型（非字面量
+  // number/string/boolean/bigint）时，删去该字面量成员（3 | number → number、
+  // "a" | string → string）。不同基底（1 | "a"）、纯字面量联合（"a" | "b"）、
+  // null/undefined 字面量不受影响；filter 保序，成员顺序稳定。
+  const primitives = deduped.filter((m) => m.kind === "primitive");
+  const absorbed =
+    primitives.length > 0
+      ? deduped.filter((m) => {
+          const base = absorbablePrimitiveBase(m);
+          return base === undefined || !primitives.some((p) => typeValueEquals(p, base));
+        })
+      : deduped;
+
+  if (absorbed.length === 0) return T.never;
+  if (absorbed.length === 1) return absorbed[0];
+  if (absorbed.some((m) => m.kind === "unknown")) return T.unknown;
+  return { kind: "union", members: absorbed };
+}
+
+/**
+ * 吸收律辅助：返回 tv 可被吸收进的原语基类型（number/string/boolean/bigint）。
+ * 仅数字/字符串/布尔/bigint 字面量与模板字面量（refined over T.string）有值；
+ * null/undefined 字面量 widen 后仍是字面量、基类型原语与其余类型不参与吸收
+ * （基类型自身不能被自己吸收，否则纯原语联合 number | string 会被误删）。
+ */
+function absorbablePrimitiveBase(tv: TypeValue): TypeValue | undefined {
+  if (tv.kind === "literal") {
+    const widened = widenLiteral(tv);
+    return widened.kind === "primitive" ? widened : undefined;
+  }
+  if (isTemplate(tv)) return T.string;
+  return undefined;
 }
 
 export function widenLiteral(tv: TypeValue): TypeValue {
@@ -141,11 +222,34 @@ export function widenLiteral(tv: TypeValue): TypeValue {
   if (typeof v === "number") return T.number;
   if (typeof v === "string") return T.string;
   if (typeof v === "boolean") return T.boolean;
+  // 吸收律要求 bigint 字面量能 widen 到 T.bigint
+  if (typeof v === "bigint") return T.bigint;
   if (v === null) return T.null;
   if (v === undefined) return T.undefined;
   return T.unknown;
 }
 
+/**
+ * union 成员全部为同原语基底的字面量且数量 > maxLiterals 时塌缩为该基类型；
+ * 非 union、混合类型、或数量不超限的原样返回。
+ *
+ * 复用 simplifyUnion（内含吸收律与去重）：先让「基类型已在场」的字面量被吸收
+ * （3 | number → number），再对剩余的纯字面量联合做阈值坍缩（1|2|…|20 → number）。
+ * 两步不冲突也不重复：吸收只删基类型已在场的字面量，阈值坍缩只处理无基类型
+ * 在场的纯字面量联合。
+ */
+export function collapseLiteralUnion(tv: TypeValue, maxLiterals: number): TypeValue {
+  if (tv.kind !== "union") return tv;
+  if (tv.members.length <= maxLiterals) return tv;
+  const simplified = simplifyUnion(tv.members);
+  if (simplified.kind !== "union") return simplified;
+  // 保守：成员中含非字面量（如显式 T.number 未吸收掉的异构成员）时不塌缩
+  if (!simplified.members.every((m) => m.kind === "literal")) return simplified;
+  const first = widenLiteral(simplified.members[0]);
+  if (!simplified.members.every((m) => typeValueEquals(widenLiteral(m), first))) return simplified;
+  return first;
+}
+
 export function isSubtypeOf(a: TypeValue, b: TypeValue): boolean {
   if (b.kind === "unknown") return true;
   if (a.kind === "never") return true;
@@ -284,6 +388,27 @@ export function mergeObjectProperties(
 }
 
 export function typeValueToString(tv: TypeValue): string {
+  // Self-referential structures (x.y = x surviving a clone) would recurse
+  // infinitely: a seen-set renders revisits as an ellipsis token.
+  return typeValueToStringInner(tv, new Set());
+}
+
+function typeValueToStringInner(tv: TypeValue, seen: Set<object>, depth = 0): string {
+  // Path-scoped seen-set: a node renders "…" only while its own expansion
+  // is on the stack (a true cycle); shared singletons (T.number in two
+  // slots) still render in full. A depth cap bounds fixture-scale DAGs
+  // whose repeated shared substructure would otherwise explode the string.
+  if (depth > 48) return "…";
+  const recur = (inner: TypeValue): string => {
+    if (inner && typeof inner === "object") {
+      if (seen.has(inner)) return "…";
+      seen.add(inner);
+      const out = typeValueToStringInner(inner, seen, depth + 1);
+      seen.delete(inner);
+      return out;
+    }
+    return typeValueToStringInner(inner, seen, depth + 1);
+  };
   switch (tv.kind) {
     case "literal": {
       const v = tv.value;
@@ -300,32 +425,37 @@ export function typeValueToString(tv: TypeValue): string {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return "{}";
       const inner = entries
-        .map(([k, v]) => `${k}: ${typeValueToString(v)}`)
+        .map(([k, v]) => `${k}: ${recur(v)}`)
         .join(", ");
       return `{ ${inner} }`;
     }
     case "array":
-      return `${typeValueToString(tv.element)}[]`;
+      return `${recur(tv.element)}[]`;
     case "tuple": {
-      const inner = tv.elements.map(typeValueToString).join(", ");
+      const inner = tv.elements.map(recur).join(", ");
       return `[${inner}]`;
     }
     case "function": {
+      const sig = getFnSig(tv);
+      if (sig) {
+        const params = sig.paramTypes.map((p, i) => `${tv.params[i]}: ${recur(p)}`).join(", ");
+        return `(${params}) => ${recur(sig.returnType)}`;
+      }
       const params = tv.params.join(", ");
       return `(${params}) => ...`;
     }
     case "promise":
-      return `Promise<${typeValueToString(tv.value)}>`;
+      return `Promise<${recur(tv.value)}>`;
     case "instance": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return tv.className;
       const inner = entries
-        .map(([k, v]) => `${k}: ${typeValueToString(v)}`)
+        .map(([k, v]) => `${k}: ${recur(v)}`)
         .join(", ");
       return `${tv.className} { ${inner} }`;
     }
     case "union": {
-      return tv.members.map(typeValueToString).join(" | ");
+      return tv.members.map(recur).join(" | ");
     }
     case "never":
       return "never";
@@ -370,3 +500,14 @@ export function getPrimitiveTypeOf(tv: TypeValue): string | undefined {
 export function getRefinedBase(tv: TypeValue): TypeValue {
   return tv.kind === "refined" ? getRefinedBase(tv.base) : tv;
 }
+
+export function isFnSig(tv: TypeValue): boolean {
+  return tv.kind === "function" && "_signature" in tv;
+}
+
+export function getFnSig(tv: TypeValue): FunctionSignature | undefined {
+  if (tv.kind === "function" && "_signature" in tv) {
+    return (tv as any)._signature as FunctionSignature;
+  }
+  return undefined;
+}

package/src/refinements/index.ts

@@ -1,2 +0,0 @@
-export { createTemplate, isTemplate, getTemplateParts, concatTemplates, getKnownPrefix, getKnownSuffix } from "./template.ts";
-export { createRange, isRange, getRangeMeta, type RangeMeta } from "./range.ts";