parseman 0.37.0 → 0.38.0

package/dist/spec/index.js

@@ -350,6 +350,16 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
+function isDefinableRef(v) {
+  return !!v && typeof v === "object" && "_def" in v && v._def.tag === "lazy" && typeof v.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;
@@ -370,11 +380,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;
@@ -2913,7 +2933,7 @@ function recoverComposedRules(grammar) {
 }
 
 // src/spec/model.ts
-function ruleNameOf(c) {
+function ruleNameOf2(c) {
   return c._ruleName;
 }
 function resolveLazy(c) {
@@ -2978,7 +2998,7 @@ var Builder = class {
     if (pinned !== void 0) return { kind: "terminal", text: pinned, literal: false };
     let c = comb;
     const guard = /* @__PURE__ */ new Set();
-    while (c._def.tag === "lazy" && ruleNameOf(c) === name && !guard.has(c)) {
+    while (c._def.tag === "lazy" && ruleNameOf2(c) === name && !guard.has(c)) {
       guard.add(c);
       const next = resolveLazy(c);
       if (!next) break;
@@ -2988,7 +3008,7 @@ var Builder = class {
   }
   /** Walk any combinator. `isRuleRoot` suppresses treating it as a self-reference. */
   walk(c, isRuleRoot = false) {
-    const rn = ruleNameOf(c);
+    const rn = ruleNameOf2(c);
     if (rn !== void 0 && !isRuleRoot) {
       if (!this.record[rn]) this.record[rn] = c;
       this.enqueue(rn, c);
@@ -3105,7 +3125,7 @@ function flattenChoice(items) {
 }
 function toRecord(grammar) {
   if (isCombinator(grammar)) {
-    const name = ruleNameOf(grammar) ?? "start";
+    const name = ruleNameOf2(grammar) ?? "start";
     return { [name]: grammar };
   }
   const recovered = recoverComposedRules(grammar);