parseman 0.37.0 → 0.38.0

package/dist/plugin/index.js

@@ -2358,6 +2358,16 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
+function isDefinableRef(v2) {
+  return !!v2 && typeof v2 === "object" && "_def" in v2 && v2._def.tag === "lazy" && typeof v2.define === "function";
+}
+function ruleNameOf(r) {
+  return r._ruleName;
+}
+function isNamedRuleRefForAnotherRule(r, key) {
+  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  return name !== void 0 && name !== key;
+}
 function rules(a, b) {
   const factory = typeof a === "function" ? a : b;
   const options = typeof a === "function" ? b : a;
@@ -2378,11 +2388,21 @@ function rules(a, b) {
   for (const key of Object.keys(definitions)) {
     const placeholder = cache[key];
     const parser2 = definitions[key];
-    if (placeholder !== void 0 && typeof placeholder.define === "function") {
-      tagRule(parser2, key);
+    if (placeholder === parser2) {
+      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    }
+    if (isDefinableRef(placeholder)) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
       placeholder.define(parser2);
       placeholder._meta.firstSet = parser2._meta.firstSet;
       placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+      const alias = ref();
+      tagRule(alias, key);
+      alias.define(parser2);
+      alias._meta.firstSet = parser2._meta.firstSet;
+      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      cache[key] = alias;
     } else {
       tagRule(parser2, key);
       cache[key] = parser2;
@@ -3008,7 +3028,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.37.0";
+var PARSEMAN_VERSION = "0.38.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3062,7 +3082,7 @@ function firstSetToString(fs2) {
   if (fs2.kind === "empty") return "(empty)";
   return fs2.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
-var ruleNameOf = (p) => p._ruleName;
+var ruleNameOf2 = (p) => p._ruleName;
 var SUGGESTIONS = {
   "broad-recognizer": "if this arm leads with a keyword regex, use word('kw', boundary) / keywords([...]) \u2014 they expose an EXACT, gating first-set and lower to the same charCodeAt scan. A genuine scanTo fallback is fine; accept it in the gating snapshot if intentional.",
   "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating \u2014 use peek(X), which is zero-width AND carries X first-set.",
@@ -3220,7 +3240,7 @@ function detectAntiPatterns(rule, arms) {
   return out;
 }
 function analyzeGating(entry, opts) {
-  return analyzeGatingRules([[ruleNameOf(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function analyzeGatingRules(ruleMap, opts) {
   const raw = [];
@@ -3253,7 +3273,7 @@ function analyzeGatingRules(ruleMap, opts) {
       return;
     }
     const d = def;
-    const rule = ruleNameOf(p) ?? enclosingRule;
+    const rule = ruleNameOf2(p) ?? enclosingRule;
     if (d.tag === "choice") {
       raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
       antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
@@ -3272,7 +3292,7 @@ function analyzeGatingRules(ruleMap, opts) {
     }
     for (const k of kids) visit(k, rule);
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf(root) ?? name);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
   const perRule = /* @__PURE__ */ new Map();
   for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
   const seenInRule = /* @__PURE__ */ new Map();
@@ -3396,7 +3416,7 @@ function childrenOf(d) {
     }
   }
 }
-var ruleNameOf2 = (p) => p._ruleName;
+var ruleNameOf3 = (p) => p._ruleName;
 var fnKey = (src, fn) => src ?? (typeof fn === "function" ? String(fn) : "");
 function payloadKey(p, d) {
   switch (d.tag) {
@@ -3407,7 +3427,7 @@ function payloadKey(p, d) {
     case "keywords":
       return `keywords\0${[...d.words].join("
")}\0${d.caseInsensitive}\0${d.boundary ?? ""}`;
     case "lazy": {
-      const n = ruleNameOf2(p);
+      const n = ruleNameOf3(p);
       return n === void 0 ? `ref\0#${anonId(p)}` : `ref\0${n}`;
     }
     case "label":
@@ -3474,7 +3494,7 @@ var Interner = class {
 var MAX_RENDER = 160;
 function render(p, depth = 3) {
   const d = p._def;
-  const name = ruleNameOf2(p);
+  const name = ruleNameOf3(p);
   switch (d.tag) {
     case "literal":
       return `literal('${d.value}')`;
@@ -3653,7 +3673,7 @@ function keywordAlternationHazards(words, boundary) {
   return out;
 }
 function analyzeDuplication(entry, opts) {
-  return analyzeDuplicationRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeDuplicationRules([[ruleNameOf3(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function assertAnalyzable(ruleMap) {
   for (const [name, rule] of ruleMap) {
@@ -3694,7 +3714,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
   const visit = (p, rule, path2, enclosingNode, enclosingReducer) => {
     if (visited.has(p)) return;
     const d = p._def;
-    const own = ruleNameOf2(p);
+    const own = ruleNameOf3(p);
     const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path: path2 };
     visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
     const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
@@ -3707,12 +3727,12 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (d.tag === "lazy") {
       try {
         const target = d.thunk();
-        visit(target, ruleNameOf2(target) ?? ruleNameOf2(p) ?? here.rule, "", null, false);
+        visit(target, ruleNameOf3(target) ?? ruleNameOf3(p) ?? here.rule, "", null, false);
       } catch {
       }
     }
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name, "", null, false);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf3(root) ?? name, "", null, false);
   const accept = new Set(opts?.accept ?? []);
   const used = /* @__PURE__ */ new Set();
   const keep = (f) => {
@@ -8567,7 +8587,7 @@ function ruleDependencies(ruleMap) {
     const seen = /* @__PURE__ */ new Set();
     const walk2 = (p, isRoot) => {
       const def = p._def;
-      const boundary = def.tag === "lazy" ? p._ruleName ?? nameOf.get(p) : nameOf.get(p);
+      const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
         found.add(boundary);
         return;
@@ -9332,7 +9352,7 @@ function childrenOf3(def) {
       return [];
   }
 }
-var ruleNameOf3 = (c) => c._ruleName;
+var ruleNameOf4 = (c) => c._ruleName;
 function lazyTarget(c) {
   if (c._def.tag !== "lazy") return null;
   try {
@@ -9514,12 +9534,16 @@ var Serializer = class {
   emitted = /* @__PURE__ */ new Set();
   decls = [];
   ruleValues = /* @__PURE__ */ new Set();
+  localRuleNames = /* @__PURE__ */ new Map();
   ruleMap;
   scanSkip;
   constructor(ruleMap, scanSkip = []) {
     this.ruleMap = ruleMap;
     this.scanSkip = scanSkip;
-    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
+    for (const [name, c] of ruleMap) {
+      this.localRuleNames.set(c, name);
+      this.ruleValues.add(this.body(c));
+    }
   }
   /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
    * bracket) — it must not reach a grammar-rule ref (`g[name]`), because the
@@ -9530,7 +9554,7 @@ var Serializer = class {
     if (seen.has(c)) return;
     seen.add(c);
     if (c._def.tag === "lazy") {
-      if (ruleNameOf3(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      if (ruleNameOf4(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
       const target = lazyTarget(c);
       if (target) this.assertNoRuleRef(target, seen);
       return;
@@ -9541,7 +9565,7 @@ var Serializer = class {
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
   body(c) {
-    return c._def.tag === "lazy" && ruleNameOf3(c) !== void 0 ? lazyTarget(c) ?? c : c;
+    return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
@@ -9583,7 +9607,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   analyze(c, active) {
     const def = c._def;
     if (def.tag === "lazy") {
-      if (ruleNameOf3(c) !== void 0) return;
+      if (ruleNameOf4(c) !== void 0) return;
       const target = lazyTarget(c);
       if (!target) throw new Unserializable("unresolved unnamed ref");
       if (active.has(target)) {
@@ -9635,7 +9659,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     const kid = (x) => this.ref(x, selfOf);
     switch (def.tag) {
       case "lazy": {
-        if (ruleNameOf3(c) !== void 0) return `g[${JSON.stringify(ruleNameOf3(c))}]`;
+        const name = this.localRuleNames.get(c) ?? ruleNameOf4(c);
+        if (name !== void 0) return `g[${JSON.stringify(name)}]`;
         const target = lazyTarget(c);
         if (selfOf && target === selfOf.comb) return selfOf.var;
         return this.ref(target, selfOf);
@@ -10145,6 +10170,25 @@ function stripTsFromSource(node2, code) {
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
 }
+function wordFactoryFromArgs(args, scope, code, mfs) {
+  const [boundaryOrOptsArg, optsArg] = args;
+  if (boundaryOrOptsArg?.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
+  const rawBoundaryOrOpts = boundaryOrOptsArg === void 0 ? void 0 : anyValue(boundaryOrOptsArg, scope, code, mfs);
+  const boundaryOrOpts = rawBoundaryOrOpts === void 0 ? "_0-9A-Za-z" : rawBoundaryOrOpts;
+  const opts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs);
+  if (typeof boundaryOrOpts === "string") {
+    if (opts !== void 0 && (typeof opts !== "object" || opts === null || Array.isArray(opts))) return null;
+    const caseInsensitive2 = typeof opts === "object" && opts !== null && "caseInsensitive" in opts ? opts.caseInsensitive : false;
+    if (typeof caseInsensitive2 !== "boolean") return null;
+    return { tag: "wordFactory", boundary: boundaryOrOpts, caseInsensitive: caseInsensitive2 };
+  }
+  if (typeof boundaryOrOpts !== "object" || boundaryOrOpts === null || Array.isArray(boundaryOrOpts) || opts !== void 0) {
+    return null;
+  }
+  const caseInsensitive = "caseInsensitive" in boundaryOrOpts ? boundaryOrOpts.caseInsensitive : false;
+  if (typeof caseInsensitive !== "boolean") return null;
+  return { tag: "wordFactory", boundary: "_0-9A-Za-z", caseInsensitive };
+}
 var SUPPORTED = {
   literal: (...a) => literal(a[0], a[1]),
   regex: (...a) => regex(a[0], a[1]),
@@ -10228,14 +10272,13 @@ function exprToCombi(node2, scope, code, mfs) {
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type === "CallExpression" && callee.callee.type === "Identifier" && callee.callee.name === "makeWord") {
-    const boundaryArg = callee.arguments[0];
     const strArg = node2.arguments[0];
     if (!strArg || strArg.type === "SpreadElement") return null;
-    const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code, mfs) : "_0-9A-Za-z";
+    const factory2 = wordFactoryFromArgs(callee.arguments, scope, code, mfs);
     const str = anyValue(strArg, scope, code, mfs);
-    if (typeof boundary !== "string" || typeof str !== "string") return null;
+    if (factory2 === null || typeof str !== "string") return null;
     try {
-      return word(str, boundary);
+      return word(str, factory2.boundary, { caseInsensitive: factory2.caseInsensitive });
     } catch {
       return null;
     }
@@ -10248,7 +10291,7 @@ function exprToCombi(node2, scope, code, mfs) {
       const str = anyValue(strArg, scope, code, mfs);
       if (typeof str !== "string") return null;
       try {
-        return word(str, factory2.boundary);
+        return word(str, factory2.boundary, { caseInsensitive: factory2.caseInsensitive });
       } catch {
         return null;
       }
@@ -10558,10 +10601,7 @@ function anyValue(node2, scope, code, mfs) {
   if (node2.type === "CallExpression") {
     const callee = node2.callee;
     if (callee.type === "Identifier" && callee.name === "makeWord") {
-      const boundaryArg = node2.arguments[0];
-      const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code, mfs) : "_0-9A-Za-z";
-      if (typeof boundary !== "string") return null;
-      return { tag: "wordFactory", boundary };
+      return wordFactoryFromArgs(node2.arguments, scope, code, mfs);
     }
     return exprToCombi(node2, scope, code, mfs);
   }
@@ -10571,10 +10611,7 @@ function evaluateWordFactory(node2, scope, code) {
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type !== "Identifier" || callee.name !== "makeWord") return null;
-  const boundaryArg = node2.arguments[0];
-  const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code) : "_0-9A-Za-z";
-  if (typeof boundary !== "string") return null;
-  return { tag: "wordFactory", boundary };
+  return wordFactoryFromArgs(node2.arguments, scope, code);
 }
 function evaluateExpr(node2, scope, code, mapFnSources) {
   return exprToCombi(node2, scope, code, mapFnSources);
@@ -10669,6 +10706,11 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
     r._ruleName = name;
     if (r._def.tag === "node" && r._def.type === void 0) r._def.type = name;
   };
+  const ruleNameOf5 = (r) => r._ruleName;
+  const isNamedRuleRefForAnotherRule2 = (r, key) => {
+    const name = r._def.tag === "lazy" ? ruleNameOf5(r) : void 0;
+    return name !== void 0 && name !== key;
+  };
   for (const key of keys) {
     if (!ruleRefs.has(key)) {
       const r = ref();
@@ -10699,12 +10741,15 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
   for (const [key, e] of finalByKey) {
     const val = anyValue(e.value, e.scope, e.code, mapFnSources);
     if (!isCombinator(val)) return null;
-    tagRef(val, key);
+    if (val === ruleRefs.get(key)) return null;
+    if (!isNamedRuleRefForAnotherRule2(val, key)) {
+      tagRef(val, key);
+    }
     ruleRefs.get(key).define(val);
   }
   return ruleRefs;
 }
-function isDefinableRef(v2) {
+function isDefinableRef2(v2) {
   return isCombinator(v2) && typeof v2.define === "function" && v2._def.tag === "lazy";
 }
 function evaluateRefDeclaration(init, name, scope) {
@@ -10726,7 +10771,7 @@ function applyDefineStatement(callExpr, scope, code) {
   if (mem.object.type !== "Identifier" || !mem.object.name) return false;
   const target = scope.get(mem.object.name);
   const refCombi = isScopeEntry(target) ? target.combi : isCombinator(target) ? target : null;
-  if (!refCombi || !isDefinableRef(refCombi)) return false;
+  if (!refCombi || !isDefinableRef2(refCombi)) return false;
   const args = callExpr.arguments;
   if (args.length !== 1 || args[0].type === "SpreadElement") return false;
   const inner = anyValue(args[0], scope, code, []);