@nudojs/parser 0.1.0 → 0.3.0

package/src/directives.ts

@@ -1,5 +1,6 @@
 import type { Node, Comment } from "@babel/types";
-import { type TypeValue, T } from "@nudojs/core";
+import { type TypeValue, type MockHelper, T, createEnvironment, stub, spy, mock } from "@nudojs/core";
+import { parse as babelParse } from "./parse.ts";
 
 export type CaseDirective = {
   kind: "case";
@@ -14,6 +15,16 @@ export type MockDirective = {
   name: string;
   expression?: string;
   fromPath?: string;
+  arrowFn?: { params: string[]; body: Node; paramPatterns: Node[] };
+  sinonExpr?: SinonExpression;
+  nudoMock?: MockHelper;
+};
+
+export type SinonExpression = {
+  type: "stub" | "spy" | "mock";
+  returnValue?: TypeValue;
+  resolvedValue?: TypeValue;
+  rejectedValue?: TypeValue;
 };
 
 export type PureDirective = {
@@ -30,12 +41,34 @@ export type SampleDirective = {
   count: number;
 };
 
-export type ReturnsDirective = {
-  kind: "returns";
-  expected: TypeValue;
+export type EnvDirective = {
+  kind: "env";
+  envs: string[];
+};
+
+export type MockModuleDirective = {
+  kind: "mock-module";
+  source: string;
+  names?: string[];
+  fromPath: string;
+};
+
+export type AsDirective = {
+  kind: "as";
+  typeExpr: TypeValue;
+};
+
+export type ReplaceDirective = {
+  kind: "replace";
+  targetSource: string;
+  typeExpr: TypeValue;
 };
 
-export type Directive = CaseDirective | MockDirective | PureDirective | SkipDirective | SampleDirective | ReturnsDirective;
+export type InlineDirective = AsDirective | ReplaceDirective;
+
+export type FileDirective = EnvDirective | MockModuleDirective;
+
+export type Directive = CaseDirective | MockDirective | PureDirective | SkipDirective | SampleDirective;
 
 export type FunctionWithDirectives = {
   node: Node;
@@ -49,7 +82,6 @@ const MOCK_FROM_REGEX = /@nudo:mock\s+(\w+)\s+from\s+"([^"]+)"/g;
 const PURE_REGEX = /@nudo:pure\b/g;
 const SKIP_REGEX = /@nudo:skip(?:\s+(.+))?/g;
 const SAMPLE_REGEX = /@nudo:sample\s+(\d+)/g;
-const RETURNS_REGEX = /@nudo:returns\s*\(/g;
 
 export function parseTypeValueExpr(expr: string): TypeValue {
   const s = expr.trim();
@@ -111,6 +143,16 @@ export function parseTypeValueExpr(expr: string): TypeValue {
     return T.object({});
   }
 
+  // Function literals: (x) => expr, x => expr, (x, y) => expr, function(x) { ... }
+  if (findTopLevelArrow(s) !== -1 || /^function\s*[\w$]*\s*\(/.test(s)) {
+    const fnExpr = parseArrowFunctionExpr(s);
+    if (fnExpr) {
+      const fnType = T.fn(fnExpr.params, fnExpr.body, createEnvironment());
+      (fnType as any)._paramPatterns = fnExpr.paramPatterns;
+      return fnType;
+    }
+  }
+
   if (/^-?\d+(\.\d+)?$/.test(s)) return T.literal(Number(s));
 
   if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
@@ -183,6 +225,17 @@ function findTopLevelColon(s: string): number {
   return -1;
 }
 
+function findTopLevelArrow(s: string): number {
+  let depth = 0;
+  for (let i = 0; i < s.length - 1; i++) {
+    const ch = s[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (depth === 0 && ch === "=" && s[i + 1] === ">") return i;
+  }
+  return -1;
+}
+
 function extractBalancedParens(text: string, startIdx: number): string | null {
   if (text[startIdx] !== "(") return null;
   let depth = 0;
@@ -194,6 +247,276 @@ function extractBalancedParens(text: string, startIdx: number): string | null {
   return null;
 }
 
+function parseArrowFunctionExpr(expr: string): { params: string[]; body: Node; paramPatterns: Node[] } | null {
+  // Try to parse as an arrow function expression
+  try {
+    // Wrap in a variable declaration to make it a valid statement
+    const wrapped = `const __mock = ${expr};`;
+    const ast = babelParse(wrapped);
+
+    const decl = ast.program.body[0];
+    if (decl.type !== "VariableDeclaration") return null;
+
+    const init = decl.declarations[0]?.init;
+    if (!init || (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression")) {
+      return null;
+    }
+
+    const params: string[] = [];
+    const paramPatterns: Node[] = [];
+    for (let i = 0; i < init.params.length; i++) {
+      const param = init.params[i];
+      if (param.type === "Identifier") {
+        params.push(param.name);
+        paramPatterns.push(param);
+      } else if (param.type === "RestElement" && param.argument.type === "Identifier") {
+        // Handle rest parameters: (...args) => ...
+        params.push(`...${param.argument.name}`);
+        paramPatterns.push(param);
+      } else if (param.type === "ArrayPattern" || param.type === "ObjectPattern") {
+        // Handle destructuring patterns: ([a, b]) => ... or ({x, y}) => ...
+        params.push(`__destructured_${i}`);
+        paramPatterns.push(param);
+      }
+    }
+
+    return { params, body: init.body, paramPatterns };
+  } catch {
+    return null;
+  }
+}
+
+function parseSinonExpr(expr: string): SinonExpression | null {
+  const s = expr.trim();
+
+  // Match sinon.stub().returns(value)
+  const stubReturnsMatch = s.match(/^sinon\.stub\(\)\.returns\((.+)\)$/);
+  if (stubReturnsMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(stubReturnsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().resolves(value)
+  const stubResolvesMatch = s.match(/^sinon\.stub\(\)\.resolves\((.+)\)$/);
+  if (stubResolvesMatch) {
+    return {
+      type: "stub",
+      resolvedValue: parseTypeValueExpr(stubResolvesMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().rejects(value)
+  const stubRejectsMatch = s.match(/^sinon\.stub\(\)\.rejects\((.+)\)$/);
+  if (stubRejectsMatch) {
+    return {
+      type: "stub",
+      rejectedValue: parseTypeValueExpr(stubRejectsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().onFirstCall().returns(value)
+  const onFirstCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onFirstCall\(\)\.returns\((.+)\)$/);
+  if (onFirstCallReturnsMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(onFirstCallReturnsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().onSecondCall().returns(value)
+  const onSecondCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onSecondCall\(\)\.returns\((.+)\)$/);
+  if (onSecondCallReturnsMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(onSecondCallReturnsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().onThirdCall().returns(value)
+  const onThirdCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onThirdCall\(\)\.returns\((.+)\)$/);
+  if (onThirdCallReturnsMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(onThirdCallReturnsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().onCall(n).returns(value)
+  const onCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onCall\(\d+\)\.returns\((.+)\)$/);
+  if (onCallReturnsMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(onCallReturnsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().withArgs(args).returns(value)
+  const withArgsReturnsMatch = s.match(/^sinon\.stub\(\)\.withArgs\(.+\)\.returns\((.+)\)$/);
+  if (withArgsReturnsMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(withArgsReturnsMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub().callsFake(fn)
+  const callsFakeMatch = s.match(/^sinon\.stub\(\)\.callsFake\((.+)\)$/);
+  if (callsFakeMatch) {
+    // For callsFake, we try to parse the function as an arrow function
+    const arrowFn = parseArrowFunctionExpr(callsFakeMatch[1].trim());
+    if (arrowFn) {
+      return {
+        type: "stub",
+        returnValue: T.fn(arrowFn.params, arrowFn.body, createEnvironment()),
+      };
+    }
+    return { type: "stub" };
+  }
+
+  // Match sinon.stub().returns(value).onFirstCall().returns(otherValue)
+  // This is a complex chain - we'll just use the first .returns() value
+  const complexChainMatch = s.match(/^sinon\.stub\(\)\.returns\((.+)\)\./);
+  if (complexChainMatch) {
+    return {
+      type: "stub",
+      returnValue: parseTypeValueExpr(complexChainMatch[1].trim()),
+    };
+  }
+
+  // Match sinon.stub() (no chaining)
+  if (s === "sinon.stub()") {
+    return { type: "stub" };
+  }
+
+  // Match sinon.spy()
+  if (s === "sinon.spy()") {
+    return { type: "spy" };
+  }
+
+  // Match sinon.mock()
+  if (s === "sinon.mock()") {
+    return { type: "mock" };
+  }
+
+  return null;
+}
+
+function parseNudoMockExpr(expr: string): MockHelper | null {
+  const s = expr.trim();
+
+  // Match stub().returns(value).onFirstCall()
+  const stubReturnsOnFirstMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onFirstCall\(\)$/);
+  if (stubReturnsOnFirstMatch) {
+    const helper = stub.returns(parseTypeValueExpr(stubReturnsOnFirstMatch[1].trim()));
+    helper.onFirstCallValue = helper.returnValue;
+    return helper;
+  }
+
+  // Match stub().returns(value).onSecondCall()
+  const stubReturnsOnSecondMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onSecondCall\(\)$/);
+  if (stubReturnsOnSecondMatch) {
+    return stub.returns(parseTypeValueExpr(stubReturnsOnSecondMatch[1].trim()));
+  }
+
+  // Match stub().returns(value).onCall(n)
+  const stubReturnsOnCallMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onCall\(\d+\)$/);
+  if (stubReturnsOnCallMatch) {
+    return stub.returns(parseTypeValueExpr(stubReturnsOnCallMatch[1].trim()));
+  }
+
+  // Match stub().callsFake((args) => body)
+  const stubCallsFakeMatch = s.match(/^stub\(\)\.callsFake\((.+)\)$/);
+  if (stubCallsFakeMatch) {
+    const helper: MockHelper = { kind: "mock-helper" };
+    helper.callsFakeImpl = parseTypeValueExpr(stubCallsFakeMatch[1].trim());
+    return helper;
+  }
+
+  // Match stub().withArgs(args).returns(value)
+  const stubWithArgsMatch = s.match(/^stub\(\)\.withArgs\((.+)\)\.returns\((.+)\)$/);
+  if (stubWithArgsMatch) {
+    const retVal = parseTypeValueExpr(stubWithArgsMatch[2].trim());
+    const argsStr = stubWithArgsMatch[1].trim();
+    const args = splitTopLevelArgs(argsStr).map(parseTypeValueExpr);
+    // 返回值只挂在 withArgs 分支上（sinon 语义：实参匹配才返回），不设全局
+    // returnValue —— 否则未命中调用会错误复用链返回值
+    const helper: MockHelper = { kind: "mock-helper" };
+    helper.withArgsCases = [{ args, returnValue: retVal }];
+    return helper;
+  }
+
+  // Match stub().onFirstCall().returns(value) —— 链在 returns 上取值
+  const stubOnFirstReturnsMatch = s.match(/^stub\(\)\.onFirstCall\(\)\.returns\((.+)\)$/);
+  if (stubOnFirstReturnsMatch) {
+    return stub.returns(parseTypeValueExpr(stubOnFirstReturnsMatch[1].trim()));
+  }
+
+  // Match stub().onFirstCall(value) —— 无 returnValue 时 TypeValue/Abs 均作默认返回
+  // [^()]* 避免把 onFirstCall().returns(...) 的尾链吞进实参
+  const stubOnFirstValueMatch = s.match(/^stub\(\)\.onFirstCall\(([^()]*)\)$/);
+  if (stubOnFirstValueMatch && stubOnFirstValueMatch[1].trim() !== "") {
+    const helper: MockHelper = { kind: "mock-helper" };
+    helper.onFirstCallValue = parseTypeValueExpr(stubOnFirstValueMatch[1].trim());
+    return helper;
+  }
+
+  // Match spy().returns(value)
+  const spyReturnsMatch = s.match(/^spy\(\)\.returns\((.+)\)$/);
+  if (spyReturnsMatch) {
+    return spy.returns(parseTypeValueExpr(spyReturnsMatch[1].trim()));
+  }
+
+  // Match stub().resolves(value).onFirstCall()
+  const stubResolvesOnFirstMatch = s.match(/^stub\(\)\.resolves\((.+)\)\.onFirstCall\(\)$/);
+  if (stubResolvesOnFirstMatch) {
+    return stub.resolves(parseTypeValueExpr(stubResolvesOnFirstMatch[1].trim()));
+  }
+
+  // Match stub().returns(value)
+  const stubReturnsMatch = s.match(/^stub\(\)\.returns\((.+)\)$/);
+  if (stubReturnsMatch) {
+    return stub.returns(parseTypeValueExpr(stubReturnsMatch[1].trim()));
+  }
+
+  // Match stub().resolves(value)
+  const stubResolvesMatch = s.match(/^stub\(\)\.resolves\((.+)\)$/);
+  if (stubResolvesMatch) {
+    return stub.resolves(parseTypeValueExpr(stubResolvesMatch[1].trim()));
+  }
+
+  // Match stub().rejects(value)
+  const stubRejectsMatch = s.match(/^stub\(\)\.rejects\((.+)\)$/);
+  if (stubRejectsMatch) {
+    return stub.rejects(parseTypeValueExpr(stubRejectsMatch[1].trim()));
+  }
+
+  // Match stub()
+  if (s === "stub()") {
+    return stub();
+  }
+
+  // Match spy()
+  if (s === "spy()") {
+    return spy();
+  }
+
+  // Match mock()
+  if (s === "mock()") {
+    return mock();
+  }
+
+  // sinon 前缀链统一为同一 MockHelper 形态：strip 前缀后复用裸 stub 解析，
+  // 使下游（applyMocks → mockHelperToTypeValue）两条路径消费一致。
+  // 解析不出的 sinon 链仍回落 sinonExpr 路径（parseSinonExpr 自己的分支）。
+  if (s.startsWith("sinon.")) {
+    return parseNudoMockExpr(s.slice("sinon.".length));
+  }
+
+  return null;
+}
+
 function parseDirectivesFromComments(comments: readonly Comment[]): Directive[] {
   const directives: Directive[] = [];
   for (const comment of comments) {
@@ -218,10 +541,29 @@ function parseDirectivesFromComments(comments: readonly Comment[]): Directive[]
         ([s, e]) => mockMatch!.index >= s && mockMatch!.index < e,
       );
       if (inFromRange) continue;
+
+      const expr = mockMatch[2].trim();
+      let arrowFn = parseArrowFunctionExpr(expr);
+      const sinonExpr = parseSinonExpr(expr);
+      const nudoMock = parseNudoMockExpr(expr);
+
+      // callsFake 统一：sinon.stub().callsFake(fn) / stub().callsFake(fn) 都把
+      // fn 提升到 arrowFn 字段——与 @nudo:mock f = (x) => ... 走完全同一绑定机制
+      // （applyMocks 的 T.fn + _paramPatterns + 全局 env 闭包），调用时以实参求值
+      if (!arrowFn) {
+        const callsFakeChain = expr.match(/^(?:sinon\.)?stub\(\)\.callsFake\((.+)\)$/);
+        if (callsFakeChain) {
+          arrowFn = parseArrowFunctionExpr(callsFakeChain[1].trim());
+        }
+      }
+
       directives.push({
         kind: "mock",
         name: mockMatch[1],
-        expression: mockMatch[2].trim(),
+        expression: expr,
+        arrowFn: arrowFn ?? undefined,
+        sinonExpr: sinonExpr ?? undefined,
+        nudoMock: nudoMock ?? undefined,
       });
     }
 
@@ -266,21 +608,15 @@ function parseDirectivesFromComments(comments: readonly Comment[]): Directive[]
     while ((sampleMatch = SAMPLE_REGEX.exec(text)) !== null) {
       directives.push({ kind: "sample", count: Number(sampleMatch[1]) });
     }
-
-    RETURNS_REGEX.lastIndex = 0;
-    let returnsMatch: RegExpExecArray | null;
-    while ((returnsMatch = RETURNS_REGEX.exec(text)) !== null) {
-      const parenStart = returnsMatch.index + returnsMatch[0].length - 1;
-      const argsStr = extractBalancedParens(text, parenStart);
-      if (argsStr === null) continue;
-      directives.push({ kind: "returns", expected: parseTypeValueExpr(argsStr) });
-    }
   }
   return directives;
 }
 
 function getFunctionName(node: Node): string {
   if (node.type === "FunctionDeclaration" && node.id) return node.id.name;
+  if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id) {
+    return node.declaration.id.name;
+  }
   if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
     return node.declaration.id.name;
   }
@@ -310,3 +646,109 @@ export function extractDirectives(ast: Node): FunctionWithDirectives[] {
 
   return results;
 }
+
+const AS_REGEX = /^\s*@nudo:as\s+(.+)/;
+const REPLACE_REGEX = /^\s*@nudo:replace\s+(.+)/;
+
+export function extractInlineDirectives(node: Node): InlineDirective[] {
+  const comments = (node as any).leadingComments as Comment[] | undefined;
+  if (!comments) return [];
+
+  const results: InlineDirective[] = [];
+  for (const comment of comments) {
+    if (comment.type !== "CommentLine") continue;
+    const text = comment.value;
+
+    const asMatch = text.match(AS_REGEX);
+    if (asMatch) {
+      results.push({ kind: "as", typeExpr: parseTypeValueExpr(asMatch[1].trim()) });
+      continue;
+    }
+
+    const replaceMatch = text.match(REPLACE_REGEX);
+    if (replaceMatch) {
+      const raw = replaceMatch[1].trim();
+      const sepIdx = findReplaceSeparator(raw);
+      if (sepIdx !== -1) {
+        const targetSource = raw.slice(0, sepIdx).trim();
+        const typeExprStr = raw.slice(sepIdx + 1).trim();
+        results.push({
+          kind: "replace",
+          targetSource,
+          typeExpr: parseTypeValueExpr(typeExprStr),
+        });
+      }
+    }
+  }
+  return results;
+}
+
+function findReplaceSeparator(raw: string): number {
+  let depth = 0;
+  let inString: string | null = null;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (inString) {
+      if (ch === inString && raw[i - 1] !== "\\") inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") { inString = ch; continue; }
+    if (ch === "(" || ch === "[" || ch === "{") { depth++; continue; }
+    if (ch === ")" || ch === "]" || ch === "}") { depth--; continue; }
+    if (ch === " " && depth === 0) {
+      const rest = raw.slice(i + 1).trimStart();
+      if (rest.startsWith("T.") || rest.startsWith("{") || rest.startsWith("[") ||
+          rest.startsWith('"') || rest.startsWith("'") ||
+          /^-?\d/.test(rest) || rest === "true" || rest === "false" ||
+          rest === "null" || rest === "undefined") {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+const ENV_REGEX = /^\/\s*@nudo:env\s+(.+)/;
+const MOCK_MODULE_REGEX = /^\/\s*@nudo:mock-module\s+"([^"]+)"\s+from\s+"([^"]+)"/;
+const MOCK_MODULE_PARTIAL_REGEX = /^\/\s*@nudo:mock-module\s+"([^"]+)"\s*\{([^}]+)\}\s*from\s+"([^"]+)"/;
+
+export function extractFileDirectives(ast: Node): FileDirective[] {
+  const results: FileDirective[] = [];
+  if (ast.type !== "File") return results;
+
+  const comments: readonly Comment[] = (ast as any).comments ?? [];
+  for (const comment of comments) {
+    if (comment.type !== "CommentLine") continue;
+    const text = comment.value;
+
+    const partialMatch = text.match(MOCK_MODULE_PARTIAL_REGEX);
+    if (partialMatch) {
+      const names = partialMatch[2].split(",").map((n) => n.trim()).filter(Boolean);
+      results.push({
+        kind: "mock-module",
+        source: partialMatch[1],
+        names,
+        fromPath: partialMatch[3],
+      });
+      continue;
+    }
+
+    const mockModuleMatch = text.match(MOCK_MODULE_REGEX);
+    if (mockModuleMatch) {
+      results.push({
+        kind: "mock-module",
+        source: mockModuleMatch[1],
+        fromPath: mockModuleMatch[2],
+      });
+      continue;
+    }
+
+    const envMatch = text.match(ENV_REGEX);
+    if (envMatch) {
+      const envs = envMatch[1].split(",").map((e) => e.trim()).filter(Boolean);
+      results.push({ kind: "env", envs });
+    }
+  }
+
+  return results;
+}

package/src/index.ts

@@ -1,13 +1,23 @@
 export { parse } from "./parse.ts";
+// stripTypes 单源在 core（parser 依赖 core，避免双份拷贝漂移）
+export { stripTypes } from "@nudojs/core";
 export {
   type Directive,
+  type FileDirective,
+  type InlineDirective,
+  type AsDirective,
+  type ReplaceDirective,
   type CaseDirective,
   type MockDirective,
   type PureDirective,
   type SkipDirective,
   type SampleDirective,
-  type ReturnsDirective,
+  type EnvDirective,
+  type MockModuleDirective,
   type FunctionWithDirectives,
+  type SinonExpression,
   extractDirectives,
+  extractFileDirectives,
+  extractInlineDirectives,
   parseTypeValueExpr,
 } from "./directives.ts";

package/src/parse.ts

@@ -1,10 +1,15 @@
-import { parse as babelParse } from "@babel/parser";
+import { parseSource } from "@nudojs/core";
 import type { File } from "@babel/types";
 
-export function parse(source: string): File {
-  return babelParse(source, {
-    sourceType: "module",
-    plugins: ["typescript", "jsx"],
-    attachComment: true,
-  });
+/**
+ * 与 core `parseSource` 同一实现与 AST LRU：
+ * 决策：parse() 统一做 TS 剥除（不按 .ts 路径开关）。理由：parse() 的产物被
+ * CLI/service/LSP/evaluator 全链消费，按调用方 opt-in 会漏掉无法感知文件扩展名
+ * 的消费方（analyzer 的模块解析、LSP 等）；对纯 JS 源码剥除是结构性 no-op，
+ * 默认行为不变，因此无条件执行可让 .ts 输入在所有入口零接线生效。
+ *
+ * errorRecovery 走 core 的非缓存路径，避免污染会话 AST。
+ */
+export function parse(source: string, opts?: { errorRecovery?: boolean }): File {
+  return parseSource(source, opts);
 }