parseman 0.47.0 → 0.47.1

package/src/table/encode.ts

@@ -9,7 +9,7 @@ import { asciiFoldKey, branchUsesRouted, parserUsesRouted } from '../combinators
 import {
   OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
-  OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_EXPECT, OP_SEQX, OP_SCAN,
+  OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE, OP_ATTEMPT, OP_LABEL,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD,
   OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_COV,
@@ -610,7 +610,7 @@ class Encoder {
     // straight to the body's offset (`case 'lazy'`), so every recursive call and
     // every cross-rule reference would jump past the counter, and a grammar with
     // one entry would report one hit rule however much of it ran.
-    this.rules[name] = amb === undefined ? body : this.emit(OP_SCOPE, this.triviaSlot(amb), body)
+    this.rules[name] = amb === undefined ? body : this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), body)
   }
 
   /**
@@ -656,7 +656,7 @@ class Encoder {
     const amb = p._meta.grammarTrivia ?? target._meta.grammarTrivia
     if (amb === undefined || this.activeTrivia !== undefined) return ip
     if (!hasOwnTriviaBoundary(target)) return ip
-    return this.emit(OP_SCOPE, this.triviaSlot(amb), ip)
+    return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), ip)
   }
 
   node(p: Combinator<unknown>): Emitted {
@@ -1399,7 +1399,7 @@ class Encoder {
       switch (this.code[ip]) {
         case OP_GATE: return [ip + 2]
         case OP_RULE: case OP_OPT: case OP_NOT: case OP_PEEK: case OP_EXPECT: case OP_ATTEMPT: case OP_LABEL: case OP_COV: return [ip + 1]
-        case OP_SCOPE: case OP_SCOPE_CAP: case OP_WITHCTX: case OP_XFORM: case OP_LEAF: case OP_NODE: case OP_NODE_TRACK: return [ip + 2]
+        case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM: case OP_LEAF: case OP_NODE: case OP_NODE_TRACK: return [ip + 2]
         case OP_SEQ: case OP_SEQV: return Array.from({ length: this.code[ip + 1]! }, (_, i) => ip + 2 + i)
         case OP_SEQX: return Array.from({ length: this.code[ip + 2]! }, (_, i) => ip + 3 + i)
         // ARMS START AT ip+4. `ip+3` is the choice's own EXPECTED-SET index, and

package/src/table/exec.ts

@@ -6,7 +6,7 @@ import { projectChild, unwrapChild } from '../combinators/node.ts'
 import { asciiFoldEq } from '../combinators/literal.ts'
 import { cstOutputHost } from '../compiler/build-arity.ts'
 import { consumeTrivia } from '../combinators/trivia-skip.ts'
-import { advanceTrivia, needsDeferredTriviaCommit, rollbackTrivia, rollbackTriviaAt, saveTriviaMark, scanTrivia, skipTriviaScanned, type FastTriviaScanner } from '../combinators/trivia-skip.ts'
+import { advanceTrivia, needsDeferredTriviaCommit, rollbackScannedTriviaAt, rollbackTrivia, rollbackTriviaAt, saveTriviaMark, scanTrivia, skipTriviaScanned, type FastTriviaScanner } from '../combinators/trivia-skip.ts'
 import {
   beginCstNodeCapture, cstCaptureActive, cstLeavesLen, cstRawLen, cstTlLen,
   demoteCapturedToRaw, endCstNodeCapture, pushCstChild, pushCstLeaf,
@@ -14,7 +14,7 @@ import {
 import {
   OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
-  OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_EXPECT, OP_SEQX, OP_SCAN,
+  OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD, OP_ATTEMPT, OP_LABEL,
   OP_COV,
@@ -609,15 +609,21 @@ function makeDriver(
           usesRouted = spec.routed[arm] === 1
         }
 
-        const savedRouted = ctx._routed
         let mark = saveTriviaMark(ctx)
+        let v: unknown
         if (usesRouted) {
+          const savedRouted = ctx._routed
           rollbackTrivia(ctx, selectorMark)
           mark = saveTriviaMark(ctx)
           ctx._routed = { value: key, span: { start: pos, end: selEnd } }
+          try {
+            v = exec(target, input, pos, ctx)
+          } finally {
+            ctx._routed = savedRouted
+          }
+        } else {
+          v = exec(target, input, selEnd, ctx)
         }
-        const v = exec(target, input, usesRouted ? pos : selEnd, ctx)
-        if (usesRouted) ctx._routed = savedRouted
         if (v === FAIL) {
           rollbackTrivia(ctx, mark)
           // The interpreter marks a failed dispatch branch COMMITTED: the
@@ -706,7 +712,8 @@ function makeDriver(
       }
 
       case OP_SCOPE:
-      case OP_SCOPE_CAP: {
+      case OP_SCOPE_CAP:
+      case OP_SCOPE_PLAIN: {
         const ki = code[ip + 1]!
         const saved = ctx.trivia
         const savedLabels = ctx.triviaKindLabels
@@ -735,7 +742,7 @@ function makeDriver(
         // (`grammar.ts:141`), and the flag is restored here because the table
         // shares one ctx where `parser()` copies it. Bit 2 = the unclassified-scope
         // refusal `grammar.ts:98` raises.
-        const policy = code[ip + 3]!
+        const policy = code[ip] === OP_SCOPE_PLAIN ? 0 : code[ip + 3]!
         if ((policy & 2) !== 0) refuseUnclassifiedRootScope(ctx._rootTriviaStrictScopes)
         const savedRootCap = ctx._rootTriviaCapture
         if ((policy & 1) !== 0) ctx._rootTriviaCapture = false
@@ -786,18 +793,19 @@ function makeDriver(
             // SCALAR MARKS — `saveTriviaMark` allocated TWICE per term (its own
             // seven-field object plus the five-field CST mark it delegates to).
             const need = rollbackNeeded(ctx)
-            const mRaw = need ? cstRawLen(ctx) : 0
             const mTl = need ? cstTlLen(ctx) : 0
-            const mLv = need ? cstLeavesLen(ctx) : 0
-            const mFl = need ? ctx._fields?.length ?? 0 : 0
-            const mEr = need ? ctx._errors?.length ?? 0 : 0
             const mLog = need ? ctx._triviaLog?.length ?? 0 : 0
             const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
             const scanEnd = skipTrivia(input, cur, ctx)
+            const scanTl = need ? cstTlLen(ctx) : 0
+            const scanLog = need ? ctx._triviaLog?.length ?? 0 : 0
+            const scanRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
             const v = exec(child, input, scanEnd, ctx)
             if (v === FAIL) { if (REC) ctx._sync = inheritedSync; return FAIL }
             if (EC.e > scanEnd) cur = EC.e
-            else if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
+            else if (need) rollbackScannedTriviaAt(
+              ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot,
+            )
             if (values !== undefined) values.push(v)
             continue
           }

package/src/table/ops.ts

@@ -104,12 +104,14 @@ export const OP_LIT_TRACK = 17
 export const OP_RX_TRACK = 18
 export const OP_NODE_TRACK = 19
 /**
- * `SCOPE k c` — a `parser({ trivia })` / `rules({ trivia })` scope.
+ * `SCOPE k c policy` — a policy-bearing `parser({ trivia })` scope.
  *
  * `k` is the scope's trivia COMBINATOR in the const pool. The driver installs it
  * on `ctx.trivia` for the duration and restores the outer one after, which is
  * how the runtime's own `advanceTrivia` fast scanner gets reached — the same
  * shared machinery the interpreter uses, not a second copy of it.
+ * Synthetic rule-entry/restoration scopes use `OP_SCOPE_PLAIN` so a zero
+ * policy stays a three-word row without changing this opcode's ABI.
  */
 export const OP_SCOPE = 20
 /**
@@ -425,6 +427,11 @@ export const OP_LABEL = 39
  * which is the granularity the IDs are minted at.
  */
 export const OP_COV = 40
+/**
+ * `SCOPE_PLAIN k c` — a synthetic ambient-trivia scope with policy fixed to zero.
+ * A distinct opcode prevents the next row's opcode from being read as policy.
+ */
+export const OP_SCOPE_PLAIN = 41
 /**
  * `DISPATCH sel d other otherRouted n a1 … an` — `dispatch()`.
  *
@@ -456,4 +463,5 @@ export const OP_NAMES: Record<number, string> = {
   [OP_ADJ]: 'ADJ',
   [OP_GREEDY]: 'GREEDY', [OP_REJECT]: 'REJECT', [OP_ARMGATE]: 'ARMGATE',
   [OP_LIVE]: 'LIVE', [OP_ATTEMPT]: 'ATTEMPT', [OP_LABEL]: 'LABEL', [OP_COV]: 'COV',
+  [OP_SCOPE_PLAIN]: 'SCOPE_PLAIN',
 }

package/src/table/program.ts

@@ -124,7 +124,8 @@ export type TableProgram = {
    */
   readonly runtimeOnly?: readonly string[]
   /**
-   * Trivia specs, referenced by index from `OP_SCOPE` and from the rule entries.
+   * Trivia specs, referenced by index from `OP_SCOPE`, `OP_SCOPE_CAP` and
+   * `OP_SCOPE_PLAIN` rule/restoration entries.
    *
    * `classifiedTrivia()` is `trivia(oneOrMore(choice(label(name, arm)…)))` with
    * regex arms — entirely structural, so it lowers to DATA and is rebuilt at
@@ -352,6 +353,26 @@ export type ResolvedDispatchSpec = {
   readonly expected: readonly string[]
 }
 
+/** Refuse malformed dispatch arm references before closure/emitted linking. */
+export function validateDispatchSpec(
+  spec: ResolvedDispatchSpec | undefined,
+  arity: number,
+  fallbackRouted: number,
+): asserts spec is ResolvedDispatchSpec {
+  const invalid = (arms: Iterable<number>): boolean => {
+    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true
+    return false
+  }
+  if (spec === undefined || !Number.isInteger(arity) || arity < 0
+    || (fallbackRouted !== 0 && fallbackRouted !== 1)
+    || spec.routed.length !== arity
+    || spec.routed.some(value => value !== 0 && value !== 1)
+    || invalid(spec.byKey.values()) || invalid(spec.byFold.values())
+    || spec.match.some(matcher => invalid([matcher[3]]))) {
+    throw new TypeError('table: malformed dispatch')
+  }
+}
+
 /** A char class expanded for execution: O(1) for ASCII, ranges above it. */
 export type ResolvedClass = {
   readonly ascii: Uint8Array

package/src/table/site-labels.ts

@@ -62,7 +62,7 @@
 import {
   OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF,
   OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE,
-  OP_SCOPE, OP_SCOPE_CAP, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
+  OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
 } from './ops.ts'
 import { childSlots } from './child-slots.ts'
 
@@ -138,7 +138,7 @@ export function reachableSites(code: Int32Array, roots: Iterable<number>): Set<n
  */
 function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean): SiteLabel {
   const op = code[ip]
-  if (op === OP_SCOPE || op === OP_SCOPE_CAP) {
+  if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
     const ki = code[ip + 1]!
     const tri = ki < 0 ? TRI_NONE : ki
     // `OP_SCOPE_CAP` is an OR with the inherited context, never a switch-off

package/src/table/stamp.ts

@@ -14,7 +14,7 @@ import type { Combinator, ParseContext, ParseResult } from '../types.ts'
 import { FUSED_HOST_ELIDED, FUSED_HOST_MODE } from '../cst/host-mode.ts'
 import { GRAMMAR_COVERAGE_DEFINITIONS } from '../grammar-metadata.ts'
 import { reachableIps } from './inspect.ts'
-import { OP_NODE, OP_NODE_TRACK, OP_SCOPE } from './ops.ts'
+import { OP_NODE, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_PLAIN } from './ops.ts'
 import { covDefinitions, resolveTable, type ResolvedTable, type TableProgram, type TableRule } from './program.ts'
 
 const EMPTY_FX: string[] = []
@@ -103,7 +103,7 @@ export function stampRuleMap(
   // `scanSkipOf` exists for). The owning driver passes its resolved table, so
   // this is the exact trivia array it already built.
   const triviaOfRule = (ip: number): Combinator<unknown> | undefined => {
-    if (prog.code[ip] !== OP_SCOPE) return undefined
+    if (prog.code[ip] !== OP_SCOPE_PLAIN && prog.code[ip] !== OP_SCOPE) return undefined
     const slot = prog.code[ip + 1]!
     return slot < 0 ? undefined : resolved.trivia[slot]
   }

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.47.0'
+export const PARSEMAN_VERSION = '0.47.1'