@nudojs/parser 1.2.1 → 1.3.0

package/dist/index.d.ts

@@ -188,8 +188,9 @@ declare function takeDirectiveDiagsSince(since: number): DirectiveDiag[];
 /**
  * case 实参 / 指令类型表达式唯一文法：约束构建器优先，其余为具体字面量、
  * 结构字面量与箭头函数。`T.*` 文法已物理删除。
+ * depth 按包含关系逐层 +1 线程化传递（兄弟共享父深度，不用共享可变计数器）。
  */
-declare function parseCaseArgExpr(expr: string): Abs;
+declare function parseCaseArgExpr(expr: string, depth?: number): Abs;
 /**
  * D6=G2：指令绑定 AST 最近 Function（含 nested function、class method）。
  * 作用域清单与 refine 的 @nudo:contract 同源（core directive-scan），

package/dist/index.js

@@ -170,6 +170,7 @@ function paramName(param) {
   return void 0;
 }
 function unwrapDefaultExport(mod) {
+  if (mod == null) return void 0;
   if (typeof mod === "function") return mod;
   return mod.default;
 }
@@ -189,6 +190,7 @@ import {
   execNudoModule,
   isNudoConstraint,
   constraintToEntryAbs,
+  CONSTRAINT_BUILDER_NAMES,
   CONSTRAINT_EXPR_RE,
   SELF,
   listFnDirectiveScopes,
@@ -258,18 +260,94 @@ function emitDirectiveDiag(d) {
 function resetDirectiveDiagSeen() {
   directiveDiagSeen.clear();
 }
-var CASE_TAG_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:case\s+([^\n]+)/g;
+var CASE_TAG_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:case\b[ \t]*([^\n]*)/g;
 var JS_IDENT_RE = /^[\p{L}$_][\p{L}\p{N}$_]*$/u;
-var MOCK_INLINE_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:mock\s+([^\s=]+)\s*=\s*(.+)/g;
-var MOCK_FROM_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:mock\s+([^\s]+)\s+from\s+"([^"]+)"/g;
-var MOCK_TAG_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:mock\s+([^\n]+)/g;
-var PURE_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:pure\b/g;
-var SKIP_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:skip\b(?:[ \t]+(\S[^\n]*))?/g;
-var SAMPLE_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*)?@nudo:sample\b(?:[ \t]+(\S+))?/g;
+var MOCK_INLINE_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:mock\b[ \t]+([^\s=]+)[ \t]*=[ \t]*(.+)/g;
+var MOCK_FROM_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:mock\b[ \t]+([^\s]+)[ \t]+from[ \t]+"([^"\n]+)"/g;
+var MOCK_TAG_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:mock\b[ \t]*([^\n]*)/g;
+var PURE_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:pure\b/g;
+var SKIP_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:skip\b(?:[ \t]+(\S[^\n]*))?/g;
+var SAMPLE_REGEX = /(?:^|\n)[ \t]*(?:\*[ \t]*|\/[ \t]*)?@nudo:sample\b(?:[ \t]+(\S+))?/g;
 var SAMPLE_NUM_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+var TYPE_EXPR_CHAIN_METHODS = /* @__PURE__ */ new Set([
+  "gt",
+  "ge",
+  "lt",
+  "le",
+  "int",
+  "min",
+  "max",
+  "length",
+  "shift",
+  "optional"
+]);
+function isSafeTypeExprNode(node) {
+  switch (node.type) {
+    case "NumericLiteral":
+    case "StringLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+      return true;
+    case "Identifier":
+      return node.name === "undefined";
+    case "UnaryExpression":
+      return node.operator === "-" && node.argument.type === "NumericLiteral";
+    case "ArrayExpression":
+      return node.elements.every(
+        (el) => el !== null && el.type !== "SpreadElement" && isSafeTypeExprNode(el)
+      );
+    case "ObjectExpression":
+      return node.properties.every((prop) => {
+        if (prop.type !== "ObjectProperty") return false;
+        if (prop.computed) return false;
+        const key = prop.key;
+        if (key.type !== "Identifier" && key.type !== "StringLiteral") return false;
+        return isSafeTypeExprNode(prop.value);
+      });
+    case "CallExpression": {
+      const argsOk = node.arguments.every(
+        (arg) => arg.type !== "SpreadElement" && arg.type !== "ArgumentPlaceholder" && isSafeTypeExprNode(arg)
+      );
+      if (!argsOk) return false;
+      return isSafeTypeExprCallee(node.callee);
+    }
+    default:
+      return false;
+  }
+}
+function isSafeTypeExprCallee(node) {
+  if (node.type === "Identifier") {
+    return CONSTRAINT_BUILDER_NAMES.includes(node.name);
+  }
+  if (node.type === "MemberExpression") {
+    if (node.computed) return false;
+    if (node.property.type !== "Identifier") return false;
+    if (!TYPE_EXPR_CHAIN_METHODS.has(node.property.name)) return false;
+    return isSafeTypeExprNode(node.object);
+  }
+  return false;
+}
+function isSafeTypeExprSource(s) {
+  try {
+    const ast = parse(`(${s});`);
+    if (ast.program.body.length !== 1) return false;
+    const stmt = ast.program.body[0];
+    if (stmt.type !== "ExpressionStatement") return false;
+    return isSafeTypeExprNode(stmt.expression);
+  } catch {
+    return false;
+  }
+}
 function tryParseConstraint(expr) {
   const s = expr.trim();
   if (!CONSTRAINT_EXPR_RE.test(s)) return void 0;
+  if (!isSafeTypeExprSource(s)) {
+    emitDirectiveDiag({
+      code: "nudo:directive-syntax",
+      message: `Unsafe constraint expression rejected: ${s.slice(0, 80)} (only builder calls, chain methods, and literals are allowed)`
+    });
+    return void 0;
+  }
   try {
     const src = `export const __nudo_case_arg = (${s});`;
     const exports = execNudoModule(src);
@@ -305,9 +383,10 @@ function constraintSelfEqLit(c, selfIds) {
   if (isSelf(b) && a.op === "lit") return { found: true, value: a.value };
   return { found: false };
 }
-function constraintToCaseArgAbs(c) {
+function constraintToCaseArgAbs(c, depth) {
+  if (depth > MAX_CASE_ARG_DEPTH) return depthCapDiag(constraintPreview(c));
   if (c.members && c.members.length > 0) {
-    const parts = c.members.map((m) => constraintToCaseArgAbs(m));
+    const parts = c.members.map((m) => constraintToCaseArgAbs(m, depth + 1));
     if (parts.length === 1) return parts[0];
     return { shape: { k: "sum", members: parts }, conf: "path" };
   }
@@ -322,12 +401,12 @@ function constraintToCaseArgAbs(c) {
     return absUndefLit();
   }
   if (c.element) {
-    return absExact({ k: "arr", element: constraintToCaseArgAbs(c.element) });
+    return absExact({ k: "arr", element: constraintToCaseArgAbs(c.element, depth + 1) });
   }
   if (c.fields) {
     const slots = {};
     for (const [key, field] of Object.entries(c.fields)) {
-      slots[key] = { value: constraintToCaseArgAbs(field.constraint) };
+      slots[key] = { value: constraintToCaseArgAbs(field.constraint, depth + 1) };
     }
     return absExact({ k: "obj", slots });
   }
@@ -340,18 +419,34 @@ function constraintToCaseArgAbs(c) {
   }
   return constraintToEntryAbs(c, "__arg");
 }
-function parseCaseArgExpr(expr) {
+var MAX_CASE_ARG_DEPTH = 32;
+function depthCapDiag(expr) {
+  emitDirectiveDiag({
+    code: "nudo:directive-syntax",
+    message: `Type expression nesting exceeds depth ${MAX_CASE_ARG_DEPTH}: ${expr.trim().slice(0, 40)} \u2026 (deeper structure collapses to unknown)`
+  });
+  return absUnknown();
+}
+function constraintPreview(c) {
+  if (c.element) return "array(\u2026)";
+  if (c.members) return "union(\u2026)";
+  if (c.fields) return "shape({ \u2026 })";
+  if (c.fn) return "fn(\u2026)";
+  return c.prim ? `${c.prim}()` : "constraint";
+}
+function parseCaseArgExpr(expr, depth = 0) {
+  if (depth > MAX_CASE_ARG_DEPTH) return depthCapDiag(expr);
   const constraint = tryParseConstraint(expr);
   if (constraint) {
     try {
-      return constraintToCaseArgAbs(constraint);
+      return constraintToCaseArgAbs(constraint, depth);
     } catch {
       return absUnknown();
     }
   }
-  return parseLiteralOrStructure(expr);
+  return parseLiteralOrStructure(expr, depth);
 }
-function parseLiteralOrStructure(expr) {
+function parseLiteralOrStructure(expr, depth) {
   const s = expr.trim();
   if (s === "true") return absLit(true);
   if (s === "false") return absLit(false);
@@ -370,17 +465,20 @@ function parseLiteralOrStructure(expr) {
     return absLit(s.slice(1, -1));
   }
   if (s.startsWith("{") && s.endsWith("}")) {
-    return parseObjectLiteral(s.slice(1, -1).trim());
+    return parseObjectLiteral(s.slice(1, -1).trim(), depth);
   }
   if (s.startsWith("[") && s.endsWith("]")) {
     const content = s.slice(1, -1).trim();
     if (!content) return absExact({ k: "tuple", elements: [] });
     const elements = splitTopLevelArgs(content);
-    return absExact({ k: "tuple", elements: elements.map((e) => parseCaseArgExpr(e)) });
+    return absExact({
+      k: "tuple",
+      elements: elements.map((e) => parseCaseArgExpr(e, depth + 1))
+    });
   }
   return absUnknown();
 }
-function parseObjectLiteral(content) {
+function parseObjectLiteral(content, depth) {
   if (!content) return absExact({ k: "obj", slots: {} });
   const entries = splitTopLevelArgs(content);
   const slots = {};
@@ -389,7 +487,7 @@ function parseObjectLiteral(content) {
     if (colonIdx === -1) continue;
     const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
     const val = entry.slice(colonIdx + 1).trim();
-    slots[key] = { value: parseCaseArgExpr(val) };
+    slots[key] = { value: parseCaseArgExpr(val, depth + 1) };
   }
   return absExact({ k: "obj", slots });
 }
@@ -555,6 +653,13 @@ function parseSkipReturnsExpr(rest) {
     if (inner !== null && s.slice(inner.length + 2).trim() === "") {
       return parseAbsExprDiag(inner, "@nudo:skip (...)");
     }
+    if (inner === null) {
+      emitDirectiveDiag({
+        code: "nudo:directive-syntax",
+        message: `@nudo:skip type expression has unclosed parenthesis (expected @nudo:skip (<typeExpr>)) \u2014 got: ${s.slice(0, 60)}`
+      });
+      return void 0;
+    }
   }
   return void 0;
 }
@@ -648,7 +753,8 @@ function parseSinonExpr(expr) {
   return null;
 }
 function parseNudoMockExpr(expr) {
-  const s = expr.trim();
+  let s = expr.trim();
+  while (s.startsWith("sinon.")) s = s.slice("sinon.".length);
   const stubReturnsOnFirstMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onFirstCall\(\)$/);
   if (stubReturnsOnFirstMatch) {
     const helper = stub.returns(parseAbsExpr(stubReturnsOnFirstMatch[1].trim()));
@@ -719,9 +825,6 @@ function parseNudoMockExpr(expr) {
   if (s === "mock()") {
     return mock();
   }
-  if (s.startsWith("sinon.")) {
-    return parseNudoMockExpr(s.slice("sinon.".length));
-  }
   return null;
 }
 function parseDirectivesFromCommentTexts(comments) {
@@ -831,8 +934,17 @@ function scanMalformedCaseNames(text, caseArgSpans) {
   while ((m = CASE_TAG_REGEX.exec(text)) !== null) {
     if (inCaseArgs(m.index)) continue;
     const rest = m[1].trim();
-    if (/^"[^"]+"\s*\(/.test(rest)) continue;
-    if (/^"[^"]+"\s*\(/.test(rest)) continue;
+    const legal = rest.match(/^("[^"]+")[ \t]*\(/);
+    if (legal) {
+      const parenIdx = m.index + m[0].length - m[1].length + legal[0].length - 1;
+      if (extractBalancedParens(text, parenIdx) === null) {
+        emitDirectiveDiag({
+          code: "nudo:directive-syntax",
+          message: `Malformed @nudo:case: unclosed argument list (missing closing ")") \u2014 got: @nudo:case ${rest.slice(0, 60)}`
+        });
+      }
+      continue;
+    }
     let reason;
     if (rest.startsWith("'")) {
       reason = `single-quoted name (use double quotes: @nudo:case "name" (\u2026))`;
@@ -872,6 +984,14 @@ function scanMalformedMockNames(text, caseArgSpans) {
         code: "nudo:directive-syntax",
         message: `Malformed @nudo:mock name '${name}': not a valid identifier (use letters, digits, _, $; Unicode letters allowed)`
       });
+      continue;
+    }
+    const afterName = rest.slice(name.length);
+    if (/^[ \t]+from[ \t]+"[^"\n]*$/.test(afterName)) {
+      emitDirectiveDiag({
+        code: "nudo:directive-syntax",
+        message: `Malformed @nudo:mock from: unclosed quote in path (expected @nudo:mock ${name} from "path") \u2014 got: @nudo:mock ${rest.slice(0, 60)}`
+      });
     }
   }
 }
@@ -898,9 +1018,32 @@ function extractDirectivesQuiet(ast) {
   takeDirectiveDiagsSince(since);
   return out;
 }
-var AS_REGEX = /^\s*@nudo:as\s+(.+)/;
-var REPLACE_REGEX = /^\s*@nudo:replace\s+(.+)/;
-var AS_TRAILING_COMMENT_RE = /\s+(?:\/\/|\/\*)/;
+function stripInlineCommentPrefix(line, kind) {
+  const s = kind === "block" ? line.replace(/^\s*\*\s?/, "") : line.replace(/^\//, "");
+  return s.trim();
+}
+var AS_LINE_REGEX = /^@nudo:as[ \t]+(.+)$/;
+var REPLACE_LINE_REGEX = /^@nudo:replace[ \t]+(.+)$/;
+var AS_BARE_RE = /^@nudo:as[ \t]*$/;
+var REPLACE_BARE_RE = /^@nudo:replace[ \t]*$/;
+function findTrailingCommentStart(expr) {
+  let inString = null;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (inString) {
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if ((ch === " " || ch === "	") && /^[ \t]+(?:\/\/|\/\*)/.test(expr.slice(i))) {
+      return i;
+    }
+  }
+  return -1;
+}
 function extractInlineDirectives(node) {
   resetDirectiveDiagSeen();
   const comments = node.leadingComments;
@@ -908,39 +1051,56 @@ function extractInlineDirectives(node) {
   const results = [];
   for (const comment of comments) {
     if (comment.type !== "CommentLine" && comment.type !== "CommentBlock") continue;
-    const text = comment.value;
-    const asMatch = text.match(AS_REGEX);
-    if (asMatch) {
-      const rawExpr = asMatch[1].trim();
-      const trailing = rawExpr.match(AS_TRAILING_COMMENT_RE);
-      if (trailing) {
-        const typePart = rawExpr.slice(0, trailing.index).trim();
+    const kind = comment.type === "CommentLine" ? "line" : "block";
+    for (const rawLine of comment.value.split("\n")) {
+      const line = stripInlineCommentPrefix(rawLine, kind);
+      const asMatch = line.match(AS_LINE_REGEX);
+      if (asMatch) {
+        const rawExpr = asMatch[1].trim();
+        const trailingIdx = findTrailingCommentStart(rawExpr);
+        if (trailingIdx !== -1) {
+          const typePart = rawExpr.slice(0, trailingIdx).trim();
+          emitDirectiveDiag({
+            code: "nudo:directive-syntax",
+            message: `Trailing comment in @nudo:as type expression: '${rawExpr}' (remove the comment; the type must be a clean expression)`
+          });
+          results.push({ kind: "as", typeAbs: typePart ? parseAbsExprDiag(typePart, "@nudo:as") : absUnknown() });
+          continue;
+        }
+        results.push({ kind: "as", typeAbs: parseAbsExprDiag(rawExpr, "@nudo:as") });
+        continue;
+      }
+      if (AS_BARE_RE.test(line)) {
         emitDirectiveDiag({
           code: "nudo:directive-syntax",
-          message: `Trailing comment in @nudo:as type expression: '${rawExpr}' (remove the comment; the type must be a clean expression)`
+          message: `@nudo:as requires a type expression (e.g. @nudo:as number())`
         });
-        results.push({ kind: "as", typeAbs: typePart ? parseAbsExprDiag(typePart, "@nudo:as") : absUnknown() });
         continue;
       }
-      results.push({ kind: "as", typeAbs: parseAbsExprDiag(rawExpr, "@nudo:as") });
-      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,
-          typeAbs: parseAbsExprDiag(typeExprStr, "@nudo:replace")
-        });
-      } else {
+      const replaceMatch = line.match(REPLACE_LINE_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,
+            typeAbs: parseAbsExprDiag(typeExprStr, "@nudo:replace")
+          });
+        } else {
+          emitDirectiveDiag({
+            code: "nudo:directive-syntax",
+            message: `Malformed @nudo:replace: cannot separate target from type (expected @nudo:replace <target> <typeExpr>) \u2014 got: ${raw.slice(0, 60)}`
+          });
+        }
+        continue;
+      }
+      if (REPLACE_BARE_RE.test(line)) {
         emitDirectiveDiag({
           code: "nudo:directive-syntax",
-          message: `Malformed @nudo:replace: cannot separate target from type (expected @nudo:replace <target> <typeExpr>) \u2014 got: ${raw.slice(0, 60)}`
+          message: `@nudo:replace requires a target and type expression (expected @nudo:replace <target> <typeExpr>)`
         });
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/parser",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "engines": {
     "node": ">=20"
   },
@@ -39,7 +39,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "1.5.0",
+    "@nudojs/core": "1.6.0",
     "@babel/types": "^8.0.6"
   },
   "scripts": {