parseman 0.50.0 → 0.50.3

package/src/table/emit-assembly.ts

@@ -259,6 +259,16 @@ function q(s: string): string {
   return JSON.stringify(s)
 }
 
+/**
+ * A code-unit lookup is a complete first-code-point decision only for a class
+ * with no non-ASCII range. At EOF `charCodeAt` yields NaN; lone surrogates and
+ * the leading surrogate of an astral point are all outside the 128-slot array,
+ * so each reads `undefined` and declines exactly as `classHas(lead(...))` does.
+ */
+function isAsciiOnlyClass(cls: ResolvedClass | null | undefined): cls is ResolvedClass {
+  return cls !== null && cls !== undefined && cls.hi.length === 0
+}
+
 /**
  * WHICH SIDE SINKS A MARK IN THIS ASSEMBLY HAS TO COVER.
  *
@@ -1259,12 +1269,15 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
 
       case OP_GATE: {
         const child = link(code[ip + 2]!)
-        const ci = classes.push([t.cc[code[ip + 1]!]!]) - 1
+        const resolved = t.cc[code[ip + 1]!]!
+        const ci = classes.push([resolved]) - 1
         classPlan.push([code[ip + 1]!])
         const cls = hoist('cl', `CLS[${ci}][0]`)
         const xf = fxRef(code[ip + 3]!)
         return `${head}
-if(!classHas(${cls},lead(input,pos))){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+if(${staticBuild && isAsciiOnlyClass(resolved)
+    ? `${cls}.ascii[input.charCodeAt(pos)]!==1`
+    : `!classHas(${cls},lead(input,pos))`}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
 }`
       }
@@ -1700,10 +1713,11 @@ return v
           // array index feeding ONE call site, which is the megamorphic site
           // this unit exists to remove.
           const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join('\n')
+          const directAscii = staticBuild && table.hi.length === 0
           return `${head}
-const c=lead(input,pos)
+const c=${directAscii ? 'input.charCodeAt(pos)' : 'lead(input,pos)'}
 let arm=-1
-if(c>=0&&c<128){const a=${asc}[c];if(a!==0)arm=a-1}
+if(${directAscii ? 'c<128' : 'c>=0&&c<128'}){const a=${asc}[c];if(a!==0)arm=a-1}
 ${hiArr.length === 0 ? '' : `else if(c>=128){const h=${hoist('hi', `DISP[${di}].hi`)}
 for(let i=0;i<h.length;i+=3){if(c>=h[i]&&c<=h[i+1]){arm=h[i+2];break}}}`}
 if(arm>=0){
@@ -1729,7 +1743,11 @@ return FAIL
           const di = code[ip + 1]!
           const expected = Array.from({ length: n }, (_, i) => fxRef(code[base + n + i]!))
           const gates = Array.from({ length: n }, (_, i) => table.armCls[i] ?? null)
-          const gateRefs = Array.from({ length: n }, (_, i) => hoist('g', `DISP[${di}].armCls[${i}]`))
+          const maskable = n <= 32
+          const directAsciiMask = staticBuild && maskable && gates.every(isAsciiOnlyClass)
+          const gateRefs = directAsciiMask
+            ? []
+            : Array.from({ length: n }, (_, i) => hoist('g', `DISP[${di}].armCls[${i}]`))
           type ChoicePretest = {
             readonly scalar?: readonly string[]
             readonly sequence?: ScalarSequenceRef
@@ -1754,7 +1772,6 @@ return FAIL
             const sequence = largeChoiceScalarSequences.get(code[base + i]!)
             return sequence === undefined ? undefined : { sequence: scalarSequenceRef(sequence) }
           })
-          const maskable = n <= 32
           const maskName = maskable
             ? hoist('mk', `MASK[${masks.push(maskForClassRow(gates)) - 1}]`)
             : ''
@@ -1856,16 +1873,16 @@ ${merge}
 ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL`
             return `${head}
-const c=lead(input,pos)
+const c=${directAsciiMask ? 'input.charCodeAt(pos)' : 'lead(input,pos)'}
 ${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ''}
 ${deepAt.map((at, i) => `let ${at},${deepFx[i]}`).join('\n')}
 ${maskable ? `if(c<128){
-const bits=${maskName}[c<0?128:c]
+const bits=${maskName}[${directAsciiMask ? 'c' : 'c<0?128:c'}]
 if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
 ${lazyArms(true)}
-}else{
+}${directAsciiMask ? '' : `else{
 ${lazyArms(false)}
-}
+}`}
 ` : lazyArms(false)}
 ${finish}
 }`
@@ -1920,7 +1937,7 @@ if(ctx._fc===true){${startFailureExact ? `if(best===pos){acc=${catchName}(${i},0
 ${rollbackFor(i)}
 }${routeMiss}${sequenceMiss}`
           }).join('\n') : ''
-          const generalArms = arms.map((arm, i) => {
+          const generalArms = directAsciiMask ? '' : arms.map((arm, i) => {
             const pretest = pretests[i]
             const decision = pretest?.token === undefined && pretest?.sequence === undefined ? '' : tmp()
             const scalarCondition = pretest?.scalar === undefined ? ''
@@ -1963,12 +1980,12 @@ ${rollbackFor(i)}
           // arm can run, so the choice's encoded flat expected set is already
           // the exact result. Do not walk the arm ladder merely to rebuild it.
           return `${head}
-const c=lead(input,pos)
+const c=${directAsciiMask ? 'input.charCodeAt(pos)' : 'lead(input,pos)'}
 ${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ''}
 let acc
 let best=pos
 ${maskable ? `if(c<128){
-const bits=${maskName}[c<0?128:c]
+const bits=${maskName}[${directAsciiMask ? 'c' : 'c<0?128:c'}]
 if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
 ${startFailureExact ? '' : 'let prev=0'}
 ${maskArms}
@@ -2076,14 +2093,20 @@ return [key,v]
         const itemFx = reportItem ? fxRef(code[ip + 6]!) : 'EMPTY_FX'
         const collect = op === OP_REP
         let itemCls: string | undefined
+        let itemAscii = false
         if (!REC) {
           const itemClassIndex = sepIp < 0 ? code[ip + 7]! : -1
           if (itemClassIndex >= 0) {
-            const ci = classes.push([t.cc[itemClassIndex]!]) - 1
+            const resolved = t.cc[itemClassIndex]!
+            const ci = classes.push([resolved]) - 1
             classPlan.push([itemClassIndex])
             itemCls = hoist('ri', `CLS[${ci}][0]`)
+            itemAscii = staticBuild && isAsciiOnlyClass(resolved)
           }
         }
+        const itemMiss = (at: string): string => itemAscii
+          ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1`
+          : `!classHas(${itemCls},lead(input,${at}))`
         const skipBeforeFirst = sepIp < 0 && min === 0
         const p = tmp()
         // `viaRepItem` is `sep === undefined && count >= min && (count > 0 ||
@@ -2199,7 +2222,7 @@ const out=${collect ? '[]' : 'undefined'}
 ${knownTrivia === undefined ? 'const hasTrivia=ctx.trivia!==undefined\n' : ''}${L.buf ? '' : 'const needMark=_rollbackNeeded(ctx)\n'}${REC ? `const ${my}=ctx._sync\n` : ''}${itemCls === undefined ? '' : `const ${p}gate=ctx._probe===undefined\n`}let cur=pos
 let count=0
 for(;;){
-${max >= 0 ? `if(count>=${max})break\n` : ''}${sep !== undefined ? `if(count>0&&count>=${min}&&cur>=input.length)break\n` : ''}${itemCls !== undefined && sep === undefined ? `if(count>=${min}&&${p}gate&&${hasTrivia === 'false' ? 'true' : hasTrivia === 'true' ? 'false' : '!hasTrivia'}&&!classHas(${itemCls},lead(input,cur)))break\n` : ''}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ''}${sinks.er ? `,${p}er=0` : ''}
+${max >= 0 ? `if(count>=${max})break\n` : ''}${sep !== undefined ? `if(count>0&&count>=${min}&&cur>=input.length)break\n` : ''}${itemCls !== undefined && sep === undefined ? `if(count>=${min}&&${p}gate&&${hasTrivia === 'false' ? 'true' : hasTrivia === 'true' ? 'false' : '!hasTrivia'}&&${itemMiss('cur')})break\n` : ''}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ''}${sinks.er ? `,${p}er=0` : ''}
 ${markBody}
 let itemStart=cur
 let sepEnd=-1
@@ -2221,7 +2244,7 @@ itemStart=${hasTrivia === 'false' ? 'EC.e' : hasTrivia === 'true' ? `${skip}(inp
 ${rb}
 ${trailingAllowed ? 'if(sepEnd>=0)cur=sepEnd\n' : ''}break
 }
-${itemCls === undefined ? '' : `if(count>=${min}&&${p}gate&&!classHas(${itemCls},lead(input,itemStart))){
+${itemCls === undefined ? '' : `if(count>=${min}&&${p}gate&&${itemMiss('itemStart')}){
 ${rb}
 ${trailingAllowed ? 'if(sepEnd>=0)cur=sepEnd\n' : ''}break
 }

package/src/table/encode.ts

@@ -145,6 +145,22 @@ class Encoder {
   private choiceRollbackMasks = new Map<number, number>()
   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.
+   */
+  private sideWriterMemo = 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
@@ -633,16 +649,19 @@ 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 = new Map<Combinator<unknown>, boolean>()
-    const hasSideWriter = (
-      current: Combinator<unknown>,
-      seen = new Set<Combinator<unknown>>(),
-    ): { found: boolean; complete: boolean } => {
+    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 }
-      const next = new Set(seen)
-      next.add(current)
+      seen.add(current)
       const def = current._def
       let result: { found: boolean; complete: boolean }
       switch (def.tag) {
@@ -657,10 +676,10 @@ class Encoder {
           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, next)
+            result = hasSideWriter(resolvedWinner)
             break
           }
-          try { result = hasSideWriter(def.thunk(), next) }
+          try { result = hasSideWriter(def.thunk()) }
           catch { result = { found: true, complete: true } }
           break
         }
@@ -668,7 +687,7 @@ class Encoder {
           let complete = true
           result = { found: false, complete: true }
           for (const child of childrenOf(def)) {
-            const childResult = hasSideWriter(child, next)
+            const childResult = hasSideWriter(child)
             if (childResult.found) {
               result = { found: true, complete: true }
               break
@@ -678,6 +697,7 @@ class Encoder {
           if (!result.found) result = { found: false, complete }
         }
       }
+      seen.delete(current)
       if (result.found || result.complete) sideWriterMemo.set(current, result.found)
       return result
     }

package/src/types.ts

@@ -115,6 +115,10 @@ export type Combinator<T> = {
   readonly _tag: string
   readonly _meta: ParserMeta
   readonly _def: ParserDef
+  /** Experimental strict interpreter ABI: end >= 0 succeeds, ~failurePos fails. */
+  readonly _parseScalar?: ((input: string, pos: number, ctx: ParseContext) => number) | undefined
+  /** Construction-owned sticky matcher for exact terminal fusion. */
+  readonly _stickyRegex?: RegExp
   parse(input: string, pos: number, ctx: ParseContext): ParseResult<T>
 }
 
@@ -311,6 +315,8 @@ export type ParseContext = {
   _fx?: string[] | undefined
   /** Framework-internal compiled-output committed-failure flag. */
   _fc?: boolean | undefined
+  /** Experimental strict interpreter semantic-value register. */
+  _sv?: unknown
   /**
    * When set by completionsAt(), tracks the highest-position ParseFail seen
    * during parsing up to _probe.offset. Used to return completions at the cursor
@@ -427,6 +433,8 @@ export type ParserMeta = {
   isTrivia: boolean
   /** User-defined labels for labeled trivia arms (`label(name, parser)`). */
   triviaKindLabels?: readonly string[]
+  /** Preclassified lightweight trivia scanner for the ordinary skip path. */
+  triviaScanner?: ((input: string, cur: number) => number) | null
   /** Set only by `classifiedTrivia()`: each root-visible category is a separate
    * grammar arm rather than an arbitrary label on a broad recognizer. */
   rootTriviaClassified?: true

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.50.0'
+export const PARSEMAN_VERSION = '0.50.3'