parseman 0.52.0 → 0.53.0

package/dist/table/index.js

@@ -3392,6 +3392,7 @@ function withRuleTrivia(trivia2, ctx, run) {
     ctx.triviaKindLabels = savedLabels;
   }
 }
+var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
 function ref() {
   let resolved = null;
   let resolvedScalar = null;
@@ -3407,7 +3408,7 @@ function ref() {
     _def: {
       tag: "lazy",
       thunk: () => {
-        if (!resolved) throw new Error("ref<T>() used before .define() was called");
+        if (!resolved) throw UNDEFINED_REF;
         return resolved;
       }
     },
@@ -13801,7 +13802,8 @@ function children(def, winners) {
         return [];
       }
       const name = resolved._ruleName;
-      return name && winners?.[name] ? [winners[name]] : [resolved];
+      const winner = name ? winners?.[name] : void 0;
+      return winner !== void 0 && winner._def !== def ? [winner] : [resolved];
     }
     default:
       return [];
@@ -13826,16 +13828,39 @@ function buildGrammarPlan(entry, winners) {
       }
     }
   }
+  const selfWinnerBody = (parser) => {
+    if (parser._def.tag !== "lazy" || winners === void 0) return void 0;
+    const name = winnerNames.get(parser);
+    if (name === void 0 || winners[name] !== parser) return void 0;
+    try {
+      return parser._def.thunk();
+    } catch {
+      return void 0;
+    }
+  };
+  const slotsPerBody = /* @__PURE__ */ new Map();
+  if (winners) {
+    for (const winner of Object.values(winners)) {
+      const body = selfWinnerBody(winner);
+      if (body !== void 0) slotsPerBody.set(body, (slotsPerBody.get(body) ?? 0) + 1);
+    }
+  }
+  const sharedBody = (parser) => (slotsPerBody.get(parser) ?? 0) > 1;
+  const ownRule = (parser, rule) => {
+    const id = `rule:${rule}`;
+    definitions.set(id, { id, kind: "rule" });
+    rules.set(parser, id);
+  };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser, path) => {
     if (seen.has(parser)) return;
     seen.add(parser);
     const rule = winnerNames.get(parser) ?? parser._ruleName;
-    if (rule && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
-      const id = `rule:${rule}`;
-      definitions.set(id, { id, kind: "rule" });
-      rules.set(parser, id);
+    const body = selfWinnerBody(parser);
+    if (rule && body === void 0 && !sharedBody(parser) && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
+      ownRule(parser, rule);
     }
+    if (rule && body !== void 0 && sharedBody(body)) ownRule(parser, rule);
     if (parser._def.tag === "choice") {
       const ids = parser._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
       choices.set(parser, ids);
@@ -13856,7 +13881,13 @@ function buildGrammarPlan(entry, winners) {
   };
   const roots = Array.isArray(entry) ? entry : [entry];
   for (const root of roots) {
-    visit(root, winnerNames.get(root) ?? root._ruleName ?? "entry");
+    const name = winnerNames.get(root) ?? root._ruleName ?? "entry";
+    const body = selfWinnerBody(root);
+    if (body !== void 0 && sharedBody(body) && !seen.has(root)) {
+      seen.add(root);
+      ownRule(root, name);
+    }
+    visit(body ?? root, name);
   }
   return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules };
 }
@@ -15162,84 +15193,8 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
-// src/table/compile.ts
-var ENTRY = "Entry";
-function ownSource(fn) {
-  if (typeof fn !== "function") return null;
-  const text = Function.prototype.toString.call(fn);
-  if (!text.includes("[native code]")) return text;
-  const name = fn.name;
-  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
-}
-function compile(combinator, mapFnSources, opts = {}) {
-  runDuplicationDiagnostic(combinator, opts.duplication);
-  const drain = beginCompileDegradationDrain();
-  let compiled = false;
-  try {
-    const out = compileImpl(combinator, mapFnSources, opts);
-    compiled = true;
-    return out;
-  } finally {
-    drain(compiled);
-  }
-}
-function compileImpl(combinator, mapFnSources, opts = {}) {
-  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
-  const settings = {
-    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
-    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
-    ...plan === void 0 ? {} : { coverage: plan }
-  };
-  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
-  const artifact = closureArtifact(prog);
-  const entry = tableRules(prog)[ENTRY];
-  const offered = opts.fnSources ?? mapFnSources;
-  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
-  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
-  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
-  const runtimeOnly = [
-    ...prog.runtimeOnly ?? [],
-    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
-  ];
-  const printable = runtimeOnly.length === 0;
-  const emitOpts = { fnSources: sources };
-  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
-  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
-  return {
-    source,
-    inlineExpression,
-    ...printable ? {} : { runtimeOnly },
-    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
-    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
-    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
-    // so this is the channel.
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    parse(input, pos = 0) {
-      return runOnce(input, pos, createParseContext());
-    },
-    parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
-    },
-    /**
-     * NO LONGER REFUSES. It used to throw unless the caller passed
-     * `{ recovery: true }`, because setting `_tolerant` on a table with no
-     * recovery rows would report a clean parse with an empty error list whatever
-     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
-     * was the wrong question. `compile()` requires no such flag, so the refusal
-     * was a `CompiledParser` contract break; recovery is now always lowered and
-     * there is nothing left to refuse.
-     */
-    parseWithErrors(input, pos = 0) {
-      const ctx = createParseContext();
-      const errors = [];
-      ctx._errors = errors;
-      ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
-      return { ...r, errors };
-    }
-  };
-}
+// src/cst/reflection-symbols.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
 
 // src/cst/reflection.ts
 function childrenOf2(def) {
@@ -15326,6 +15281,7 @@ function collectFromCombinator(parser, out, seen, followLazy = true) {
 function collectGrammarReflection(ruleMap, opts) {
   const byType = /* @__PURE__ */ new Map();
   const followLazy = opts?.followLazy !== false;
+  const seen = /* @__PURE__ */ new Set();
   for (const [, rule] of ruleMap) {
     if (!followLazy && rule._def.tag === "lazy") {
       try {
@@ -15335,7 +15291,7 @@ function collectGrammarReflection(ruleMap, opts) {
       }
       continue;
     }
-    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+    collectFromCombinator(rule, byType, seen, followLazy);
   }
   return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
 }
@@ -15371,6 +15327,24 @@ function withAmbient(ruleMap, opts) {
     return [name, wrapped];
   });
 }
+function compileRuleMapRunnable(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  const reflection = collectGrammarReflection(ruleMap);
+  return {
+    keys: ruleMap.map(([key]) => key),
+    hostMode,
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection,
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
+    // asks to specialise; every other caller runs the closure artifact.
+    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
+    prog: artifact
+  };
+}
 function encodeForRun(ruleMap, opts) {
   runDuplicationDiagnosticRules(ruleMap, opts.duplication);
   const encodeMap = withAmbient(ruleMap, opts);
@@ -15439,11 +15413,185 @@ function compileRuleMap(ruleMap, opts = {}) {
     hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
+    rules: tableRules(artifact),
     prog: artifact
   };
 }
 
+// src/compiler/borrowed-rules.ts
+var nameOf = (c) => c._ruleName;
+function deref(c) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = c;
+  while (current._def.tag === "lazy" && !seen.has(current)) {
+    seen.add(current);
+    try {
+      current = current._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  return current;
+}
+function borrowedRuleReference(map) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rule, self] of Object.entries(map)) {
+    let found;
+    const visit = (c) => {
+      if (found !== void 0) return;
+      if (c._def.tag === "lazy") {
+        if (!winnerWrapsReference(self, c)) {
+          const name = nameOf(c);
+          const winner = name !== void 0 && Object.hasOwn(map, name) ? map[name] : void 0;
+          if (winner !== void 0) {
+            if (winnerWrapsReference(winner, c) || deref(c) === deref(winner)) return;
+            found = name;
+            return;
+          }
+        }
+        if (seen.has(c)) return;
+        seen.add(c);
+        let body;
+        try {
+          body = c._def.thunk();
+        } catch {
+          return;
+        }
+        visit(body);
+        return;
+      }
+      if (seen.has(c)) return;
+      seen.add(c);
+      for (const child of childrenOf(c._def)) visit(child);
+    };
+    visit(self);
+    if (found !== void 0) return { rule, reference: found };
+  }
+  return void 0;
+}
+function borrowedRuleMessage(api, hit) {
+  return `${api}: rule "${hit.rule}" is a rule object borrowed from another grammar, and its graph references "${hit.reference}", which this grammar also defines. The interpreter would keep the other grammar's "${hit.reference}" while a compiled table binds this grammar's, so the two would accept different input. Compose the grammar that defines "${hit.rule}" instead of borrowing its rule object, so its references resolve to this grammar's rules.`;
+}
+
+// src/table/compile.ts
+var ENTRY = "Entry";
+function ownSource(fn) {
+  if (typeof fn !== "function") return null;
+  const text = Function.prototype.toString.call(fn);
+  if (!text.includes("[native code]")) return text;
+  const name = fn.name;
+  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
+}
+function compile(target, second, third) {
+  if (!isCombinator(target)) return compileMap(target, second);
+  return compileRoot(target, second, third);
+}
+function isCombinator(x) {
+  return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
+}
+function compileMap(grammar, opts = {}) {
+  const entries = [];
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (value._def.tag === "lazy") {
+      try {
+        value._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    entries.push([key, value]);
+  }
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries));
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compile", borrowed));
+  const drain = beginCompileDegradationDrain();
+  let done = false;
+  try {
+    const refusals = [];
+    const compiled = compileRuleMapRunnable(entries, {
+      ...opts.hostMode ? { hostMode: opts.hostMode } : {},
+      refusals,
+      specialise: true
+    });
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
+    }
+    done = true;
+    return compiled.rules;
+  } finally {
+    drain(done);
+  }
+}
+function compileRoot(combinator, mapFnSources, opts = {}) {
+  runDuplicationDiagnostic(combinator, opts.duplication);
+  const drain = beginCompileDegradationDrain();
+  let compiled = false;
+  try {
+    const out = compileImpl(combinator, mapFnSources, opts);
+    compiled = true;
+    return out;
+  } finally {
+    drain(compiled);
+  }
+}
+function compileImpl(combinator, mapFnSources, opts = {}) {
+  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
+  const settings = {
+    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
+    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
+  const artifact = closureArtifact(prog);
+  const entry = tableRules(prog)[ENTRY];
+  const offered = opts.fnSources ?? mapFnSources;
+  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
+  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
+  const runtimeOnly = [
+    ...prog.runtimeOnly ?? [],
+    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
+  ];
+  const printable = runtimeOnly.length === 0;
+  const emitOpts = { fnSources: sources };
+  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
+  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
+  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  return {
+    source,
+    inlineExpression,
+    ...printable ? {} : { runtimeOnly },
+    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
+    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
+    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
+    // so this is the channel.
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    parse(input, pos = 0) {
+      return runOnce(input, pos, createParseContext());
+    },
+    parseWithContext(input, parseCtx, pos = 0) {
+      return runOnce(input, pos, parseCtx);
+    },
+    /**
+     * NO LONGER REFUSES. It used to throw unless the caller passed
+     * `{ recovery: true }`, because setting `_tolerant` on a table with no
+     * recovery rows would report a clean parse with an empty error list whatever
+     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
+     * was the wrong question. `compile()` requires no such flag, so the refusal
+     * was a `CompiledParser` contract break; recovery is now always lowered and
+     * there is nothing left to refuse.
+     */
+    parseWithErrors(input, pos = 0) {
+      const ctx = createParseContext();
+      const errors = [];
+      ctx._errors = errors;
+      ctx._tolerant = true;
+      const r = runOnce(input, pos, ctx);
+      return { ...r, errors };
+    }
+  };
+}
+
 // src/table/fold.ts
 function tableVariants(source, name) {
   const folded = "base" in source ? source : expandCompactFolded(source);