parseman 0.55.0 → 0.55.2

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export declare const PARSEMAN_VERSION = "0.55.0";
+export declare const PARSEMAN_VERSION = "0.55.2";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.55.0",
+  "version": "0.55.2",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/analysis/commitment.ts

@@ -441,24 +441,41 @@ export function hasDirectBuildDef(p: Combinator<unknown>, seen: Set<Combinator<u
   }
 }
 
-/** True when `p` can report a committed failure through emitFallible's failure channel. */
+/**
+ * True when `p` can report a committed failure through emitFallible's failure
+ * channel: a `dispatch`, or a shape this analysis cannot see into, is reachable
+ * along `commitFailureSuccessors`' edges.
+ *
+ * `memo` carries exact answers between calls over one graph and one `resolve`;
+ * a caller asking at many sites passes the same map to every call, so the graph
+ * is walked once rather than once per site.
+ */
 export function mayCommitFailure(
   p: Combinator<unknown>,
-  seen: Set<Combinator<unknown>> = new Set(),
   resolve?: RefResolver,
+  memo: Map<Combinator<unknown>, boolean> = new Map(),
 ): boolean {
-  if (seen.has(p)) return false
-  seen.add(p)
+  return reachesMarked(p, node => commitFailureSuccessors(node, resolve), memo)
+}
+
+const NO_EDGES: readonly Combinator<unknown>[] = []
+
+/** `mayCommitFailure`'s edges out of `p`, or `true` when `p` itself can commit. */
+function commitFailureSuccessors(
+  p: Combinator<unknown>,
+  resolve: RefResolver | undefined,
+): readonly Combinator<unknown>[] | true {
   const d = p._def
   switch (d.tag) {
     case 'dispatch':
+    case 'unknown':
       return true
     case 'choice':
     case 'sequence':
-      return d.parsers.some(x => mayCommitFailure(x, seen, resolve))
+      return d.parsers
     // A contained transaction reports every failure uncommitted.
     case 'attempt':
-      return d.contain !== true && mayCommitFailure(d.parser, seen, resolve)
+      return d.contain === true ? NO_EDGES : [d.parser]
     case 'many':
     case 'oneOrMore':
     case 'optional':
@@ -467,32 +484,102 @@ export function mayCommitFailure(
     case 'field':
     case 'grammar':
     case 'node':
-      return mayCommitFailure(d.parser, seen, resolve)
-    case 'sepBy':
-      return mayCommitFailure(d.parser, seen, resolve) || mayCommitFailure(d.separator, seen, resolve)
     case 'token':
     case 'leaf':
-      return mayCommitFailure(d.parser, seen, resolve)
     case 'withCtx':
-      return mayCommitFailure(d.parser, seen, resolve)
+      return [d.parser]
+    case 'sepBy':
+      return [d.parser, d.separator]
     case 'scanTo':
-      return mayCommitFailure(d.sentinel, seen, resolve)
-        || d.skip.some(x => mayCommitFailure(x, seen, resolve))
-        || (d.recoverAt !== undefined && mayCommitFailure(d.recoverAt, seen, resolve))
-        || (d.stopAt !== undefined && mayCommitFailure(d.stopAt, seen, resolve))
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...(d.recoverAt === undefined ? NO_EDGES : [d.recoverAt]),
+        ...(d.stopAt === undefined ? NO_EDGES : [d.stopAt]),
+      ]
     case 'lazy': {
-      try { return mayCommitFailure(d.thunk(), seen, resolve) }
+      try { return [d.thunk()] }
       catch {
         const name = (p as unknown as { _ruleName?: string })._ruleName
         const target = name === undefined ? undefined : resolve?.(name)
-        return target === undefined ? true : mayCommitFailure(target, seen, resolve)
+        return target === undefined ? true : [target]
       }
     }
-    case 'unknown':
-      return true
     default:
-      return false
+      return NO_EDGES
+  }
+}
+
+/**
+ * Whether a MARKED node — one `successors` answers `true` for — is reachable
+ * from `root`.
+ *
+ * Reachability over a cyclic graph, decided with Tarjan's strongly connected
+ * components so that every node the walk enters leaves with its exact answer in
+ * `memo`: the members of one component reach each other, so they share one
+ * answer, settled when the walk returns to the component's first node. A DFS
+ * that instead cuts a cycle at its own ancestor path learns nothing it can keep
+ * about a node whose walk hit the cut; one that keeps a visited set per call
+ * keeps nothing past the call. Shared across calls, `memo` makes every node
+ * entered once however many roots are asked about.
+ *
+ * `memo` must only ever be used with one `successors`: its entries are answers
+ * about that graph.
+ */
+export function reachesMarked<T>(
+  root: T,
+  successors: (node: T) => readonly T[] | true,
+  memo: Map<T, boolean>,
+): boolean {
+  const known = memo.get(root)
+  if (known !== undefined) return known
+  const order = new Map<T, number>()
+  const low: number[] = []
+  const found: boolean[] = []
+  const stack: T[] = []
+  const visit = (node: T): number => {
+    const at = low.length
+    order.set(node, at)
+    low.push(at)
+    found.push(false)
+    stack.push(node)
+    const next = successors(node)
+    if (next === true) found[at] = true
+    else {
+      for (const child of next) {
+        // Settled: a node that reaches a marked node is answered, and so is
+        // every node still above it on the stack, since each reaches it. The
+        // children left unentered stay unmemoized for a later walk to settle.
+        if (found[at]) break
+        const hit = memo.get(child)
+        if (hit !== undefined) {
+          if (hit) found[at] = true
+          continue
+        }
+        const seen = order.get(child)
+        if (seen !== undefined) {
+          // Unmemoized but entered: still on the stack, so in this node's
+          // component. Its answer reaches the component's first node by the
+          // tree edges, not through here.
+          if (seen < low[at]!) low[at] = seen
+          continue
+        }
+        const k = visit(child)
+        if (low[k]! < low[at]!) low[at] = low[k]!
+        if (found[k]) found[at] = true
+      }
+    }
+    if (low[at] === at) {
+      const answer = found[at]!
+      let member: T
+      do {
+        member = stack.pop()!
+        memo.set(member, answer)
+      } while (member !== node)
+    }
+    return at
   }
+  return found[visit(root)]!
 }
 
 /** A leaf-composed imported piece may carry Parseman's own structural balanced

package/src/table/encode.ts

@@ -1,7 +1,7 @@
 import type { AutoNotCheck, Combinator, FirstSet, ParserDef } from '../types.ts'
 import { classifyFinalChoice, firstSetOf, intersects, matchesEmpty, union, type RefResolver } from '../combinators/first-set.ts'
 import { childrenOf } from '../analysis/gating.ts'
-import { capturesLeaf, mayCommitFailure, mayLeavePartialCapture } from '../analysis/commitment.ts'
+import { capturesLeaf, mayCommitFailure, mayLeavePartialCapture, reachesMarked } from '../analysis/commitment.ts'
 import { getCoreLiteralValue } from '../combinators/choice.ts'
 import { deriveExpected } from '../combinators/expect.ts'
 import { assertionFailureExpected, directTerminalFailureExpected } from '../combinators/expected.ts'
@@ -147,21 +147,20 @@ class Encoder {
   private nonCommittingChoiceSites = new Set<number>()
   private failureRollbackCleanSites = new Set<number>()
   /**
-   * `hasSideWriter` memo for `failureNeedsRollback`, shared across every call
-   * for the lifetime of this `Encoder`. A cached entry is written only when
-   * `complete` is true, which means the answer is a path-independent fact
-   * about that combinator node — it does not depend on which root's traversal
-   * asked, only on the node's own reachable subgraph. Scoping the memo per call
-   * (as a local inside `failureNeedsRollback`) was correct but discarded that
-   * fact after every arm, so a grammar with many ordered-choice arms / optional
-   * / attempt sites re-walked the SAME shared rule graph from scratch for each
-   * site — O(sites × graph size) instead of O(graph size). Measured on the
-   * scss-parser grammar (composed CSS-base superset, the deepest/largest of the
-   * four grammars): 47-50s for one `compileRuleMap` with the per-call memo,
-   * versus the whole macro transform completing in under a second once this
-   * memo is hoisted here.
+   * `reachesSideWriter`'s answers, shared by every `failureNeedsRollback` call
+   * for the lifetime of this `Encoder`. Every entry is exact — it depends only on
+   * the node's own reachable subgraph, never on which root's walk asked — so each
+   * combinator is walked once per encode however many choice arms, optionals and
+   * attempt sites reach it.
    */
   private sideWriterMemo = new Map<Combinator<unknown>, boolean>()
+  /**
+   * `mayCommitFailure`'s answers, shared by every choice site for the lifetime
+   * of this `Encoder` — exact for the graph and the `winners` resolver it is
+   * encoding, so the rule graph is walked once per encode rather than once per
+   * choice site.
+   */
+  private commitFailureMemo = new Map<Combinator<unknown>, boolean>()
   labels: readonly string[] | undefined = undefined
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia: Combinator<unknown> | undefined = undefined
@@ -653,8 +652,7 @@ class Encoder {
    * writer census covers the side sinks that proof deliberately does not model:
    * fields, recovered errors, and interpreted scanners. Strict assemblies do
    * not run repeat recovery, but these rows can still publish through a caller's
-   * context. Cycles are safe to stop: revisiting the same combinator cannot
-   * discover a writer the first traversal did not already reach.
+   * context.
    */
   private failureNeedsRollback(
     p: Combinator<unknown>,
@@ -663,63 +661,42 @@ class Encoder {
     const refName = (p as unknown as { _ruleName?: string })._ruleName
     const winner = refName === undefined ? undefined : this.winners?.[refName]
     const root = winner !== undefined && !winnerWrapsReference(winner, p) ? winner : p
-    const sideWriterMemo = this.sideWriterMemo
-    // A single mutable `seen` set threaded through the whole call, rather than
-    // copied at every recursion level: this DFS visits children strictly
-    // sequentially, so marking `current` in progress before recursing and
-    // clearing it once its subtree is fully explored reproduces the exact same
-    // ancestor-path membership an immutable copy-per-level would have computed,
-    // without the O(depth) allocation on every node.
-    const seen = new Set<Combinator<unknown>>()
-    const hasSideWriter = (current: Combinator<unknown>): { found: boolean; complete: boolean } => {
-      const cached = sideWriterMemo.get(current)
-      if (cached !== undefined) return { found: cached, complete: true }
-      if (seen.has(current)) return { found: false, complete: false }
-      seen.add(current)
-      const def = current._def
-      let result: { found: boolean; complete: boolean }
-      switch (def.tag) {
-        case 'field':
-        case 'expect':
-        case 'recover':
-        case 'scanTo':
-        case 'unknown':
-          result = { found: true, complete: true }
-          break
-        case 'lazy': {
-          const name = (current as unknown as { _ruleName?: string })._ruleName
-          const resolvedWinner = name === undefined ? undefined : this.winners?.[name]
-          if (resolvedWinner !== undefined && !winnerWrapsReference(resolvedWinner, current)) {
-            result = hasSideWriter(resolvedWinner)
-            break
-          }
-          try { result = hasSideWriter(def.thunk()) }
-          catch { result = { found: true, complete: true } }
-          break
-        }
-        default: {
-          let complete = true
-          result = { found: false, complete: true }
-          for (const child of childrenOf(def)) {
-            const childResult = hasSideWriter(child)
-            if (childResult.found) {
-              result = { found: true, complete: true }
-              break
-            }
-            complete &&= childResult.complete
-          }
-          if (!result.found) result = { found: false, complete }
-        }
-      }
-      seen.delete(current)
-      if (result.found || result.complete) sideWriterMemo.set(current, result.found)
-      return result
-    }
     return mayLeavePartialCapture(root, new Set(), true)
-      || hasSideWriter(root).found
+      || this.reachesSideWriter(root)
       || ((autoNot?.length ?? 0) > 0 && capturesLeaf(root))
   }
 
+  /**
+   * Whether a field, recovered error, interpreted scanner or unresolvable shape
+   * is reachable from `root` — the writer census of `failureNeedsRollback`,
+   * entering each combinator once per `Encoder` (see `reachesMarked`).
+   */
+  private reachesSideWriter(root: Combinator<unknown>): boolean {
+    return reachesMarked(root, node => this.sideWriterSuccessors(node), this.sideWriterMemo)
+  }
+
+  /** The census's edges out of `node`, or `true` when `node` is itself a writer. */
+  private sideWriterSuccessors(node: Combinator<unknown>): readonly Combinator<unknown>[] | true {
+    const def = node._def
+    switch (def.tag) {
+      case 'field':
+      case 'expect':
+      case 'recover':
+      case 'scanTo':
+      case 'unknown':
+        return true
+      case 'lazy': {
+        const name = (node as unknown as { _ruleName?: string })._ruleName
+        const winner = name === undefined ? undefined : this.winners?.[name]
+        if (winner !== undefined && !winnerWrapsReference(winner, node)) return [winner]
+        try { return [def.thunk()] }
+        catch { return true }
+      }
+      default:
+        return childrenOf(def)
+    }
+  }
+
   /** A first set becomes a char class string, or −1 for `any`. */
   private charClass(fs: FirstSet): number {
     if (fs.kind !== 'ranges' || fs.ranges.length === 0) return -1
@@ -1244,7 +1221,7 @@ class Encoder {
           this.code[head + 4 + kids.length + i] = this.expected(deriveExpected(arms[i]!))
         }
         this.choiceRollbackMasks.set(head, rollbackMask)
-        if (arms.every(arm => !mayCommitFailure(arm, new Set(), rr))) {
+        if (arms.every(arm => !mayCommitFailure(arm, rr, this.commitFailureMemo))) {
           this.nonCommittingChoiceSites.add(head)
         }
         return head

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.55.0'
+export const PARSEMAN_VERSION = '0.55.2'