@nudojs/service 0.2.0 → 0.3.0

package/src/mock-abs.ts

@@ -0,0 +1,275 @@
+/**
+ * @nudo:mock / sinon 指令 → Abs seed（供 evalProgramAbs）。
+ * host 层：依赖 parser 指令形态；core 只吃 seedVars/seedFns。
+ */
+
+import type { Node } from "@babel/types";
+import type { FunctionWithDirectives } from "@nudojs/parser";
+import type { MockHelper, TypeValue } from "@nudojs/core";
+import {
+  type Abs,
+  absFunction,
+  emptyEnv,
+  typeValueToAbs,
+  abs as makeAbs,
+  confJoin,
+  unknown as absUnknown,
+  litValue,
+  formatAbs,
+  getFnImpl,
+  typeValueToString,
+} from "@nudojs/core";
+
+/**
+ * mock 依赖结果 conf 不得高于 mock。
+ * 必须保留同一对象身份：absFunction 的 impl 挂在 WeakMap 上，
+ * makeAbs 新建对象会丢掉 body/apply。
+ */
+function markMockConf(a: Abs): Abs {
+  a.conf = confJoin(a.conf, "mock");
+  return a;
+}
+
+/** Structural content key for mock body AST (callsFake etc.). */
+function astContentKey(n: unknown, depth = 0): string {
+  if (n == null || depth > 24) return "";
+  if (typeof n !== "object") return String(n);
+  if (Array.isArray(n)) return n.map((x) => astContentKey(x, depth + 1)).join(",");
+  const obj = n as Record<string, unknown>;
+  const type = typeof obj.type === "string" ? obj.type : "";
+  const parts: string[] = [type];
+  for (const key of ["name", "value", "raw", "operator", "computed"]) {
+    const v = obj[key];
+    if (v !== undefined && (typeof v !== "object" || v === null)) parts.push(`${key}=${String(v)}`);
+  }
+  for (const key of Object.keys(obj)) {
+    if (
+      key === "loc" ||
+      key === "start" ||
+      key === "end" ||
+      key === "leadingComments" ||
+      key === "trailingComments" ||
+      key === "innerComments" ||
+      key === "type" ||
+      key === "name" ||
+      key === "value" ||
+      key === "raw" ||
+      key === "operator" ||
+      key === "computed"
+    ) {
+      continue;
+    }
+    const v = obj[key];
+    if (v && typeof v === "object") parts.push(`${key}:{${astContentKey(v, depth + 1)}}`);
+  }
+  return parts.join("|");
+}
+
+function stampFingerprint(a: Abs, fp: string): Abs {
+  const impl = getFnImpl(a);
+  if (impl) impl.fingerprint = fp;
+  return a;
+}
+
+/** 用常量 Abs 造 mock 函数：调用即返回该值（结果 conf 标 mock） */
+function constantMockFn(result: Abs): Abs {
+  const marked = markMockConf(result);
+  const mockEnv = emptyEnv();
+  const retName = "__nudo_mock_ret";
+  mockEnv.vars.set(retName, marked);
+  const body = {
+    type: "BlockStatement",
+    body: [
+      {
+        type: "ReturnStatement",
+        argument: { type: "Identifier", name: retName },
+      },
+    ],
+  } as unknown as Node;
+  let retKey: string;
+  try {
+    retKey = formatAbs(marked);
+  } catch {
+    retKey = "?";
+  }
+  return stampFingerprint(
+    markMockConf(absFunction(["...args"], { body, env: mockEnv })),
+    `ret=${retKey}`,
+  );
+}
+
+/**
+ * withArgs 实参匹配（与 mock-helpers.mockArgMatches 同语义）：
+ * - 字面量声明要求实参同值字面量
+ * - primitive 声明接受同源字面量
+ */
+function absArgMatches(declared: TypeValue, actual: Abs | undefined): boolean {
+  if (!actual) return false;
+  const declaredAbs = typeValueToAbs(declared);
+  // 同 shape + 同字面量
+  const av = litValue(actual);
+  const dv = litValue(declaredAbs);
+  if (dv !== undefined) {
+    return av !== undefined && Object.is(av, dv);
+  }
+  // declared 是 primitive（如 T.number）：接受同源字面量或同 prim
+  if (declared.kind === "primitive") {
+    if (actual.shape.k === "prim") return actual.shape.type === declared.type;
+    if (av !== undefined) {
+      const t = typeof av;
+      return (
+        (declared.type === "number" && t === "number") ||
+        (declared.type === "string" && t === "string") ||
+        (declared.type === "boolean" && t === "boolean") ||
+        (declared.type === "bigint" && t === "bigint")
+      );
+    }
+  }
+  // unknown 声明不视为可证明匹配
+  return false;
+}
+
+function dispatchMockFn(defaultReturn: Abs, cases?: { args: TypeValue[]; returnValue: TypeValue }[]): Abs {
+  if (!cases?.length) return constantMockFn(defaultReturn);
+  const caseAbs = cases.map((c) => ({
+    declared: c.args,
+    result: markMockConf(typeValueToAbs(c.returnValue)),
+  }));
+  const dummyBody = {
+    type: "BlockStatement",
+    body: [{ type: "ReturnStatement", argument: null }],
+  } as unknown as Node;
+  const markedDefault = markMockConf(defaultReturn);
+  let defaultKey: string;
+  try {
+    defaultKey = formatAbs(markedDefault);
+  } catch {
+    defaultKey = "?";
+  }
+  const caseKey = cases
+    .map(
+      (c) =>
+        `${c.args.map((a) => typeValueToString(a)).join(",")}->${typeValueToString(c.returnValue)}`,
+    )
+    .join("|");
+  return stampFingerprint(
+    markMockConf(
+      absFunction(["...args"], {
+        body: dummyBody,
+        env: emptyEnv(),
+        apply: (args: Abs[]): Abs => {
+          for (const c of caseAbs) {
+            if (c.declared.every((d, i) => absArgMatches(d, args[i]))) {
+              return c.result;
+            }
+          }
+          return markedDefault;
+        },
+      }),
+    ),
+    `dispatch=default=${defaultKey};cases=${caseKey}`,
+  );
+}
+
+function absFromMockHelper(h: MockHelper): Abs {
+  if (h.callsFakeImpl && h.callsFakeImpl.kind === "function") {
+    const fn = h.callsFakeImpl;
+    const body = fn.body as Node;
+    return stampFingerprint(
+      absFunction(fn.params, { body, async: false }),
+      `fake=${fn.params.join(",")}:${astContentKey(body)}`,
+    );
+  }
+
+  let defaultReturn: Abs;
+  if (h.resolvedValue) {
+    defaultReturn = makeAbs(
+      { k: "eff", eff: "promise", inner: typeValueToAbs(h.resolvedValue) },
+      undefined,
+      undefined,
+      "path",
+    );
+  } else if (h.rejectedValue) {
+    defaultReturn = makeAbs({ k: "never" }, undefined, undefined, "exact");
+  } else if (h.returnValue) {
+    defaultReturn = typeValueToAbs(h.returnValue);
+  } else if (h.onFirstCallValue) {
+    // 与 TypeValue 路径一致：无 returnValue 时 onFirstCall 作默认返回
+    defaultReturn = typeValueToAbs(h.onFirstCallValue);
+  } else {
+    defaultReturn = absUnknown;
+  }
+
+  return dispatchMockFn(defaultReturn, h.withArgsCases);
+}
+
+function absFromSinon(sinonExpr: {
+  type: string;
+  returnValue?: TypeValue;
+  resolvedValue?: TypeValue;
+  rejectedValue?: TypeValue;
+}): Abs {
+  if (sinonExpr.resolvedValue) {
+    return constantMockFn(
+      makeAbs(
+        { k: "eff", eff: "promise", inner: typeValueToAbs(sinonExpr.resolvedValue) },
+        undefined,
+        undefined,
+        "path",
+      ),
+    );
+  }
+  if (sinonExpr.rejectedValue) {
+    return constantMockFn(makeAbs({ k: "never" }, undefined, undefined, "exact"));
+  }
+  if (sinonExpr.returnValue) {
+    return constantMockFn(typeValueToAbs(sinonExpr.returnValue));
+  }
+  return constantMockFn(absUnknown);
+}
+
+export type AbsMockSeeds = {
+  seedVars: Record<string, Abs>;
+  seedFns: Record<string, { params: string[]; body: Node; async?: boolean; fingerprint?: string }>;
+};
+
+/**
+ * B 路径注入用：seedVars + seedFns 统一为 Abs 函数绑定。
+ * arrowFn mock 落在 seedFns（AST body，供 ast-eval），B 路径的
+ * envGlobals 注入只吃 Abs——不合并会把 mock 丢掉，函数体内的调用
+ * 会落到真实原生函数（如 fetch 拿 Abs 当 URL，直接崩）。
+ */
+export function mockSeedsToAbsMocks(seeds: AbsMockSeeds): Record<string, Abs> {
+  const out: Record<string, Abs> = { ...seeds.seedVars };
+  for (const [name, fn] of Object.entries(seeds.seedFns)) {
+    out[name] = absFunction(fn.params, { body: fn.body, async: fn.async ?? false });
+  }
+  return out;
+}
+
+/** 从函数上的 @nudo:mock 指令收集 Abs seed */
+export function mockDirectivesToAbsSeeds(
+  functions: Array<{ directives: FunctionWithDirectives["directives"] }>,
+): AbsMockSeeds {
+  const seedVars: Record<string, Abs> = {};
+  const seedFns: AbsMockSeeds["seedFns"] = {};
+  for (const fn of functions) {
+    for (const d of fn.directives) {
+      if (d.kind !== "mock") continue;
+      if (d.arrowFn) {
+        const body = d.arrowFn.body as Node;
+        seedFns[d.name] = {
+          params: d.arrowFn.params,
+          body,
+          async: false,
+          fingerprint: `fake=${d.arrowFn.params.join(",")}:${astContentKey(body)}`,
+        };
+      } else if (d.nudoMock) {
+        seedVars[d.name] = markMockConf(absFromMockHelper(d.nudoMock));
+      } else if (d.sinonExpr) {
+        seedVars[d.name] = markMockConf(absFromSinon(d.sinonExpr));
+      }
+    }
+  }
+  return { seedVars, seedFns };
+}

package/src/schema-generator.ts

@@ -0,0 +1,43 @@
+import type { TypeValue } from "@nudojs/core";
+
+export function typeValueToZodSchema(tv: TypeValue): string {
+  switch (tv.kind) {
+    case "literal": {
+      if (tv.value === null) return "z.null()";
+      if (tv.value === undefined) return "z.undefined()";
+      if (typeof tv.value === "string") return `z.literal(${JSON.stringify(tv.value)})`;
+      if (typeof tv.value === "boolean") return `z.literal(${tv.value})`;
+      return `z.literal(${tv.value})`;
+    }
+    case "primitive":
+      return `z.${tv.type}()`;
+    case "refined":
+      return typeValueToZodSchema(tv.base);
+    case "object": {
+      const entries = Object.entries(tv.properties)
+        .map(([k, v]) => `${k}: ${typeValueToZodSchema(v)}`)
+        .join(", ");
+      return `z.object({ ${entries} })`;
+    }
+    case "array":
+      return `z.array(${typeValueToZodSchema(tv.element)})`;
+    case "tuple": {
+      const inner = tv.elements.map(typeValueToZodSchema).join(", ");
+      return `z.tuple([${inner}])`;
+    }
+    case "function":
+      return "z.function()";
+    case "promise":
+      return `z.promise(${typeValueToZodSchema(tv.value)})`;
+    case "instance":
+      return `z.instanceof(${tv.className})`;
+    case "union": {
+      const members = tv.members.map(typeValueToZodSchema).join(", ");
+      return `z.union([${members}])`;
+    }
+    case "never":
+      return "z.never()";
+    case "unknown":
+      return "z.unknown()";
+  }
+}

package/src/semantic-tokens.ts

@@ -0,0 +1,216 @@
+import { dirname } from "node:path";
+import type { Node } from "@babel/types";
+import { createEnvironment, type Environment } from "@nudojs/core";
+import { parse } from "@nudojs/parser";
+import {
+  evaluateProgram,
+  setModuleResolver,
+  setCurrentFileDir,
+  resetMemo,
+} from "@nudojs/cli/evaluator";
+import { resolveModule } from "./analyzer.ts";
+
+/**
+ * Semantic tokens 图例（tokenTypes 下标即 LSP 编码里的 tokenType 值）。
+ * 与 LSP server capabilities 里声明的 legend 必须逐字对齐——server.ts 直接
+ * 导入本常量注册，保证「提取端索引」与「客户端图例」单一来源。
+ * 顺序沿用 lsp 包原 legend（function/variable/parameter/property 在前），
+ * 末尾追加 method（对象字面量方法键），只追加不重排，客户端索引稳定。
+ */
+export const SEMANTIC_TOKEN_TYPES = [
+  "function",
+  "variable",
+  "parameter",
+  "property",
+  "type",
+  "keyword",
+  "string",
+  "number",
+  "comment",
+  "decorator",
+  "method",
+] as const;
+
+export const SEMANTIC_TOKEN_MODIFIERS = [
+  "declaration",
+  "readonly",
+  "deprecated",
+  "unreachable",
+] as const;
+
+export type SemanticToken = {
+  line: number;
+  char: number;
+  length: number;
+  typeIndex: number;
+  modifierBitmask: number;
+};
+
+/** LSP 标准相对五元组编码：deltaLine/deltaStartChar/length/tokenType/tokenModifiers。 */
+export function encodeSemanticTokens(tokens: SemanticToken[]): number[] {
+  const result: number[] = [];
+  let prevLine = 0;
+  let prevChar = 0;
+
+  for (const token of tokens) {
+    const deltaLine = token.line - prevLine;
+    const deltaChar = deltaLine === 0 ? token.char - prevChar : token.char;
+
+    result.push(deltaLine, deltaChar, token.length, token.typeIndex, token.modifierBitmask);
+
+    prevLine = token.line;
+    prevChar = token.char;
+  }
+
+  return result;
+}
+
+const TYPE_FUNCTION = SEMANTIC_TOKEN_TYPES.indexOf("function");
+const TYPE_VARIABLE = SEMANTIC_TOKEN_TYPES.indexOf("variable");
+const TYPE_PARAMETER = SEMANTIC_TOKEN_TYPES.indexOf("parameter");
+const TYPE_PROPERTY = SEMANTIC_TOKEN_TYPES.indexOf("property");
+const TYPE_METHOD = SEMANTIC_TOKEN_TYPES.indexOf("method");
+const MOD_DECLARATION = 1 << SEMANTIC_TOKEN_MODIFIERS.indexOf("declaration");
+
+/**
+ * 从源码提取 semantic tokens 并按 LSP 相对编码返回扁平 number[]。
+ *
+ * 上色范围（声明位优先，未解析的 token 一律不上色）：
+ * - 顶层 const/let/var 声明的绑定名：推断为函数绑定 → function，否则 variable
+ *   （函数体内部的声明不做 env 反查——外层同名绑定会串味，统一 variable）；
+ * - 函数声明/函数表达式的名字 → function；所有函数的参数 → parameter；
+ * - 对象字面量的键：值为函数 → method，否则 property。
+ *
+ * 推断复用 evaluateProgram 的绑定分析（与补全/诊断同一求值链），不另建
+ * 符号体系；解析失败返回 []，求值中断则按已绑定的部分结果继续上色。
+ */
+export function buildSemanticTokens(filePath: string, source: string): number[] {
+  let ast: Node;
+  try {
+    ast = parse(source);
+  } catch {
+    return [];
+  }
+
+  const env = createEnvironment();
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname(filePath));
+  try {
+    evaluateProgram(ast, env);
+  } catch {
+    // 求值中断（如未支持语法）：尽力而为，用已落进 env 的绑定继续上色
+  } finally {
+    setModuleResolver(null);
+  }
+
+  const program = (ast as { program?: Node }).program ?? ast;
+  const ownBindings = env.getOwnBindings();
+  // 顶层声明器节点集合：仅这些绑定名做 env 反查区分 function/variable
+  const topLevelDeclarators = new Set<unknown>();
+  for (const stmt of ((program as { body?: Node[] }).body ?? []) as Node[]) {
+    const decl =
+      stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration"
+        ? ((stmt as { declaration?: Node }).declaration ?? null)
+        : stmt;
+    if (decl && decl.type === "VariableDeclaration") {
+      for (const d of (decl as unknown as { declarations: Node[] }).declarations) {
+        topLevelDeclarators.add(d);
+      }
+    }
+  }
+
+  const tokens: SemanticToken[] = [];
+  const pushIdentifier = (id: Node, typeIndex: number): void => {
+    const loc = (id as { loc?: { start: { line: number; column: number } } }).loc;
+    const name = (id as { name?: string }).name;
+    if (!loc || typeof name !== "string") return;
+    tokens.push({
+      line: loc.start.line - 1,
+      char: loc.start.column,
+      length: name.length,
+      typeIndex,
+      modifierBitmask: MOD_DECLARATION,
+    });
+  };
+
+  const collectParams = (params: Node[]): void => {
+    for (const p of params) {
+      if (!p) continue;
+      if (p.type === "Identifier") pushIdentifier(p, TYPE_PARAMETER);
+      else if (p.type === "AssignmentPattern" && (p as { left?: Node }).left?.type === "Identifier") {
+        pushIdentifier((p as { left: Node }).left, TYPE_PARAMETER);
+      } else if (p.type === "RestElement" && (p as { argument?: Node }).argument?.type === "Identifier") {
+        pushIdentifier((p as { argument: Node }).argument, TYPE_PARAMETER);
+      }
+      // 解构模式（ObjectPattern/ArrayPattern）内部不上色：子绑定的
+      // function/variable 区分没有可靠推断依据，宁缺毋滥
+    }
+  };
+
+  const isFunctionValue = (name: string): boolean =>
+    ownBindings[name]?.kind === "function";
+
+  const visit = (node: unknown): void => {
+    if (!node || typeof node !== "object") return;
+    const n = node as Record<string, unknown>;
+
+    switch (n.type) {
+      case "VariableDeclarator": {
+        const id = n.id as Node | undefined;
+        if (id?.type === "Identifier") {
+          const isTopLevel = topLevelDeclarators.has(node);
+          const typeIndex =
+            isTopLevel && isFunctionValue((id as { name: string }).name) ? TYPE_FUNCTION : TYPE_VARIABLE;
+          pushIdentifier(id, typeIndex);
+        }
+        break;
+      }
+      case "FunctionDeclaration":
+      case "FunctionExpression": {
+        const id = n.id as Node | undefined;
+        if (id?.type === "Identifier") pushIdentifier(id, TYPE_FUNCTION);
+        collectParams((n.params as Node[] | undefined) ?? []);
+        break;
+      }
+      case "ArrowFunctionExpression":
+        collectParams((n.params as Node[] | undefined) ?? []);
+        break;
+      case "ObjectMethod": {
+        const key = n.key as Node | undefined;
+        if (key?.type === "Identifier" && !n.computed) pushIdentifier(key, TYPE_METHOD);
+        collectParams((n.params as Node[] | undefined) ?? []);
+        break;
+      }
+      case "ObjectProperty": {
+        const key = n.key as Node | undefined;
+        const value = n.value as Node | undefined;
+        if (key?.type === "Identifier" && !n.computed) {
+          const isFn =
+            value?.type === "FunctionExpression" || value?.type === "ArrowFunctionExpression";
+          pushIdentifier(key, isFn ? TYPE_METHOD : TYPE_PROPERTY);
+        }
+        break;
+      }
+    }
+
+    for (const key of Object.keys(n)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+      const child = n[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && typeof (item as { type?: unknown }).type === "string") {
+            visit(item);
+          }
+        }
+      } else if (child && typeof child === "object" && typeof (child as { type?: unknown }).type === "string") {
+        visit(child);
+      }
+    }
+  };
+
+  visit(program);
+
+  tokens.sort((a, b) => a.line - b.line || a.char - b.char);
+  return encodeSemanticTokens(tokens);
+}

package/src/session-cache.ts

@@ -0,0 +1,50 @@
+/**
+ * 会话缓存失效入口（宿主契约的唯一接线点）。
+ *
+ * analyzeFile / tryRunBPath / generalize L0 的键都不含「依赖模块内容」——
+ * 入口 source 未变但 dep 变了时，必须由宿主主动逐出，否则会命中陈旧结果。
+ * LSP 走定向逐出；CLI watch / vite-plugin 走这里。
+ */
+import {
+  resetGeneralizeMemo,
+  resetCheckSourceMemo,
+  resetNudoModuleExecCache,
+  resetParseSourceCache,
+} from "@nudojs/core";
+import { clearAbsModuleCache, evictAbsModuleCacheFiles } from "./abs-modules-graph.ts";
+import { clearBPathCache, evictBPathCacheForFiles } from "./bpath-run.ts";
+import { clearAnalysisFileCache, evictAnalysisFileCacheForFiles } from "./analysis-file-cache.ts";
+import { clearFnAnalysisCache, evictFnAnalysisCacheForFiles } from "./fn-analysis-cache.ts";
+
+/**
+ * 依赖内容变更后：按入口文件定向逐出 service 层缓存。
+ * 调用方应传「以这些文件为入口」的路径（脏集里的 dependents），
+ * 而不是变更的 dep 文件本身——dep 自己 source 变了会自然 miss。
+ */
+export function evictAnalysisCachesForFiles(files: string[]): void {
+  if (files.length === 0) return;
+  evictBPathCacheForFiles(files);
+  evictAnalysisFileCacheForFiles(files);
+  evictFnAnalysisCacheForFiles(files);
+  evictAbsModuleCacheFiles(files);
+}
+
+/**
+ * 清空全部会话级分析缓存（service + core）。
+ * 适用于：CLI watch 增量批前、vite buildStart / watchChange、测试隔离。
+ * 比定向逐出重，但保证无陈旧命中；单次 analyze 内部的 per-fn / generalize
+ * memo 不受影响（它们在同一轮里先写后读）。
+ */
+export function clearAnalysisSessionCaches(): void {
+  clearBPathCache(); // cascades analysis-file + fn-analysis
+  clearAbsModuleCache();
+  resetGeneralizeMemo();
+  resetCheckSourceMemo();
+  resetNudoModuleExecCache();
+}
+
+/** 比 clearAnalysisSessionCaches 更彻底：再丢 AST LRU（测试 / 进程复用场景） */
+export function resetAllAnalysisCaches(): void {
+  clearAnalysisSessionCaches();
+  resetParseSourceCache();
+}