parseman 0.61.6 → 0.61.8

package/dist/analysis/diagnostics.js

@@ -198,8 +198,9 @@ function matchesEmptyBody(p, seen, resolve) {
     case "optional":
     case "not":
     case "peek":
+    case "expect":
       return true;
-    // zero repetitions / absent / lookahead
+    // zero repetitions / absent / lookahead / recovered
     // Default `sepBy` is `(item (sep item)*)?` — it MATCHES THE EMPTY STRING.
     // Any `min >= 1` requires that many ITEMS, so it is nullable only when the
     // item is. (Keying this off `min === 1` reported every `{ min: 2 }` list as
@@ -220,7 +221,6 @@ function matchesEmptyBody(p, seen, resolve) {
     case "trivia":
     case "token":
     case "leaf":
-    case "expect":
     case "withCtx":
     case "node":
     case "grammar":
@@ -290,17 +290,17 @@ function sequenceSet(parsers, fs, empties, trivia2, consuming = true) {
 function sequenceFirstSet(parsers) {
   return sequenceSet(parsers, (p) => p._meta.firstSet, matchesEmpty, void 0, false);
 }
-function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve, activeTrivia, consuming = true) {
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve, activeTrivia, consuming = true, follow = false) {
   if (seen.has(p)) return any();
   seen.add(p);
   try {
-    return firstSetBody(p, seen, resolve, activeTrivia, consuming);
+    return firstSetBody(p, seen, resolve, activeTrivia, consuming, follow);
   } finally {
     seen.delete(p);
   }
 }
-function firstSetBody(p, seen, resolve, activeTrivia, consuming) {
-  const fs = (c) => firstSetOf(c, seen, resolve, activeTrivia, consuming);
+function firstSetBody(p, seen, resolve, activeTrivia, consuming, follow) {
+  const fs = (c) => firstSetOf(c, seen, resolve, activeTrivia, consuming, follow);
   const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
   const d = p._def;
   switch (d.tag) {
@@ -321,7 +321,7 @@ function firstSetBody(p, seen, resolve, activeTrivia, consuming) {
         }
       }
       const through = activeTrivia === null && resolve !== void 0;
-      return firstSetOf(target, seen, resolve, through ? triviaThroughRef(p, target, null) : activeTrivia, consuming);
+      return firstSetOf(target, seen, resolve, through ? triviaThroughRef(p, target, null) : activeTrivia, consuming, follow);
     }
     case "choice": {
       let out = empty();
@@ -331,6 +331,10 @@ function firstSetBody(p, seen, resolve, activeTrivia, consuming) {
     case "sequence": {
       return sequenceSet(d.parsers, fs, empties, activeTrivia, consuming);
     }
+    // Runs on any character: on one its child can't start, it reports the error. A
+    // resync sentinel still stops where the child could start.
+    case "expect":
+      return follow ? fs(d.parser) : any();
     case "peek": {
       const inner = d.parser;
       return empties(inner) ? any() : fs(inner);
@@ -344,7 +348,6 @@ function firstSetBody(p, seen, resolve, activeTrivia, consuming) {
     case "leaf":
     case "node":
     case "sepBy":
-    case "expect":
     // A transaction accepts exactly what its inner accepts. Its own `_meta` is
     // the inner's construction-time set, which reads `any` when the inner opens
     // with a rule reference — resolve through it like any other wrapper.
@@ -352,14 +355,15 @@ function firstSetBody(p, seen, resolve, activeTrivia, consuming) {
       return fs(d.parser);
     // A token runs its body with trivia cleared (`token.ts`).
     case "token":
-      return firstSetOf(d.parser, seen, resolve, activeTrivia === void 0 ? void 0 : null, consuming);
+      return firstSetOf(d.parser, seen, resolve, activeTrivia === void 0 ? void 0 : null, consuming, follow);
     case "grammar":
       return firstSetOf(
         d.parser,
         seen,
         resolve,
         d.clearTrivia ? null : d.triviaParser ?? activeTrivia,
-        consuming
+        consuming,
+        follow
       );
     // A run starts with its first line's prefix; a nullable prefix starts with anything.
     case "lines": {
@@ -2712,7 +2716,8 @@ function derive(c, seen) {
 function expect(combinator, label2) {
   const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
   const meta = {
-    firstSet: combinator._meta.firstSet,
+    // It runs on any character: on one its child can't start, it reports the error.
+    firstSet: any(),
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
@@ -4072,7 +4077,7 @@ function regex(pattern, flags = "") {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.61.6";
+var PARSEMAN_VERSION = "0.61.8";
 
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
@@ -5041,7 +5046,7 @@ function sequence(...parsers) {
       if (tolerant) {
         followSentinels ??= parsers.map((_, i) => firstSetSentinel(
           parsers.slice(i + 1).reduce(
-            (set, parser2) => union(set, firstSetOf(parser2, /* @__PURE__ */ new Set(), void 0, void 0, false)),
+            (set, parser2) => union(set, firstSetOf(parser2, /* @__PURE__ */ new Set(), void 0, void 0, false, true)),
             { kind: "empty" }
           )
         ));
@@ -8330,7 +8335,7 @@ var Encoder = class {
     let fs = { kind: "empty" };
     const rr = this.refResolver();
     for (let j = i + 1; j < parsers.length; j++) {
-      fs = union(fs, firstSetOf(parsers[j], /* @__PURE__ */ new Set(), rr, void 0, false));
+      fs = union(fs, firstSetOf(parsers[j], /* @__PURE__ */ new Set(), rr, void 0, false, true));
     }
     return this.charClass(fs);
   }
@@ -10825,17 +10830,17 @@ var WRAPPERS = /* @__PURE__ */ new Set([
   OP_SCOPE_PLAIN,
   OP_FIELD,
   OP_LABEL,
-  OP_EXPECT,
   OP_WITHCTX,
   OP_RULE,
   OP_ATTEMPT,
   OP_COV,
   OP_GAPGATE
 ]);
-function rowNullable(code, k, ip, memo) {
-  const hit = memo.get(ip);
+function rowNullable(code, k, ip, memo, recovers = true) {
+  const key = recovers ? ip : ~ip;
+  const hit = memo.get(key);
   if (hit !== void 0) return hit;
-  memo.set(ip, true);
+  memo.set(key, true);
   const op = code[ip];
   const kids = [];
   let out = true;
@@ -10846,20 +10851,20 @@ function rowNullable(code, k, ip, memo) {
     out = !(re instanceof RegExp) || regexCanMatchEmpty(re.source);
   } else if (op === OP_SEQ || op === OP_SEQV || op === OP_SEQX) {
     childSlots(code, ip, kids);
-    out = kids.every((c) => rowNullable(code, k, c, memo));
+    out = kids.every((c) => rowNullable(code, k, c, memo, recovers));
   } else if (op === OP_CHOICE) {
     childSlots(code, ip, kids);
-    out = kids.length === 0 || kids.some((c) => rowNullable(code, k, c, memo));
+    out = kids.length === 0 || kids.some((c) => rowNullable(code, k, c, memo, recovers));
   } else if (op === OP_REP || op === OP_REPV) {
-    out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1], memo);
+    out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1], memo, recovers);
   } else if (op === OP_SEED) {
-    out = rowNullable(code, k, code[ip + 1], memo);
+    out = rowNullable(code, k, code[ip + 1], memo, recovers);
   } else if (op === OP_CONT) {
-    out = rowNullable(code, k, code[ip + 1], memo) && rowNullable(code, k, code[ip + 3], memo);
-  } else if (WRAPPERS.has(op)) {
-    if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0], memo);
+    out = rowNullable(code, k, code[ip + 1], memo, recovers) && rowNullable(code, k, code[ip + 3], memo, recovers);
+  } else if (WRAPPERS.has(op) || op === OP_EXPECT && !recovers) {
+    if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0], memo, recovers);
   }
-  memo.set(ip, out);
+  memo.set(key, out);
   return out;
 }
 function holdsGap(code, k, base, n, i, memo) {
@@ -10868,7 +10873,7 @@ function holdsGap(code, k, base, n, i, memo) {
   if (code[term] !== OP_NOT && code[term] !== OP_PEEK) return false;
   const next = code[base + i + 1];
   if (code[next] === OP_ADJ || leadingTriviaFieldAt(code, k, next)) return false;
-  return !rowNullable(code, k, next, memo);
+  return !rowNullable(code, k, next, memo, false);
 }
 
 // src/table/gap-gate.ts
@@ -11190,11 +11195,35 @@ ${fast}
 ${scanned}
 }`;
 }
-function emitHoldTerm(callee, dst, t2, l, skip) {
+var TRIVIA_LOG_LENGTH = "ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)";
+function emitHoldTerm(callee, dst, t2, l, skip, recovers) {
   const fast = `const ${t2}v=${callee}(input,cur,ctx)
 if(${t2}v===FAIL)return FAIL
 ${dst}=${t2}v
 cur=EC.e`;
+  if (recovers) {
+    const marked = `let ${t2}c=cur,${t2}s=cur,${t2}tl=0,${t2}stl=0,${t2}lg=0,${t2}slg=0,${t2}rt=0,${t2}srt=0`;
+    if (l.tri === TRI_NONE) return `${marked}
+${fast}`;
+    const held2 = `${t2}tl=${TRIVIA_LOG_LENGTH}
+${t2}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${t2}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+${t2}s=${skip}(input,cur,ctx)
+${t2}stl=${TRIVIA_LOG_LENGTH}
+${t2}slg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${t2}srt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+const ${t2}v=${callee}(input,${t2}s,ctx)
+if(${t2}v===FAIL)return FAIL
+${dst}=${t2}v
+cur=${t2}s`;
+    return l.tri !== TRI_UNKNOWN ? `${marked}
+${held2}` : `${marked}
+if(ctx.trivia===undefined){
+${fast}
+}else{
+${held2}
+}`;
+  }
   if (l.tri === TRI_NONE) return fast;
   const held = `const ${t2}s=${skip}(input,cur,ctx)
 const ${t2}v=${callee}(input,${t2}s,ctx)
@@ -11208,6 +11237,9 @@ ${fast}
 ${held}
 }`;
 }
+function emitHeldGapUndo(t2) {
+  return `if(cur===${t2}s&&${t2}s!==${t2}c){rollbackScannedTriviaAt(ctx,${t2}tl,${t2}stl,${t2}lg,${t2}slg,${t2}rt,${t2}srt);cur=${t2}c}`;
+}
 function leadSkip(hasTrivia, leadTrivia, skip) {
   if (hasTrivia === "false") return "{}";
   const call = `itemStart=${skip}(input,itemStart,ctx)`;
@@ -12216,6 +12248,7 @@ return v
         }
         parts.push("let cur=EC.e");
         const names = ["v0"];
+        let heldUndo;
         for (let i = 1; i < n; i++) {
           const vn = `v${i}`;
           parts.push(`let ${vn}`);
@@ -12232,7 +12265,16 @@ return v
             );
           } else {
             const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]})` : kids[i];
-            parts.push(holdsGap(code, k, base, n, i, nullable2) ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L)) : emitTerm(callee, vn, tmp(), L, skipFor(L), L.tri >= 0 ? triviaMiss(L.tri) : void 0));
+            if (holdsGap(code, k, base, n, i, nullable2)) {
+              const t3 = tmp();
+              const recovers = rowNullable(code, k, code[base + i + 1], nullable2);
+              parts.push(emitHoldTerm(callee, vn, t3, L, skipFor(L), recovers));
+              heldUndo = recovers ? t3 : void 0;
+            } else {
+              parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L), L.tri >= 0 ? triviaMiss(L.tri) : void 0));
+              if (heldUndo !== void 0) parts.push(emitHeldGapUndo(heldUndo));
+              heldUndo = void 0;
+            }
           }
           names.push(vn);
         }
@@ -13827,11 +13869,15 @@ function failCleanAnalysis(code) {
       case OP_CONT:
         out = clean(code[ip + 1]) && neverFails(code[ip + 3]);
         break;
-      // An arm's failure and the fallback's are committed; only the selector's is
-      // not, and without a fallback an unknown key fails after the selector wrote.
-      case OP_DISPATCH:
-        out = code[ip + 3] >= 0 && clean(code[ip + 1]);
+      // An arm's failure and a committing fallback's are committed; only the
+      // selector's is not. An uncommitted fallback's failure leaves the selector's
+      // capture, unless the fallback reads it through `routed()`, which rolls that
+      // capture back first. With no fallback, the dispatch fails after the selector wrote.
+      case OP_DISPATCH: {
+        const flags = code[ip + 4];
+        out = code[ip + 3] >= 0 && ((flags & 2) === 0 || (flags & 1) === 1) && clean(code[ip + 1]);
         break;
+      }
       default: {
         const c = passChild(code, ip);
         out = c >= 0 && clean(c);
@@ -15889,8 +15935,46 @@ function assemble(t2, prog, cfg) {
         }
         if (hasAdj) {
           const first2 = linkFirst();
+          let heldFrom = 0, heldTl = 0, heldScanTl = 0, heldLog = 0, heldScanLog = 0, heldRoot = 0, heldScanRoot = 0;
           const runnerAt = (i) => {
             const kidIp = code[base + i];
+            if (i > 1 && holdsGap(code, k, base, n, i - 1, NULLABLE) && rowNullable(code, k, kidIp, NULLABLE)) {
+              const kid = link(kidIp);
+              return (input, cur, ctx) => {
+                const from = heldFrom, tl = heldTl, scanTl = heldScanTl, log = heldLog;
+                const scanLog = heldScanLog, root = heldRoot, scanRoot = heldScanRoot;
+                const next = step(kid, input, cur, ctx);
+                if (next !== cur || from === cur) return next;
+                rollbackScannedTriviaAt(ctx, tl, scanTl, log, scanLog, root, scanRoot);
+                return from;
+              };
+            }
+            if (holdsGap(code, k, base, n, i, NULLABLE) && rowNullable(code, k, code[base + i + 1], NULLABLE)) {
+              const kid = link(kidIp);
+              return (input, cur, ctx) => {
+                if (ctx.trivia === void 0) {
+                  const v2 = kid(input, cur, ctx);
+                  if (v2 === FAIL) return -1;
+                  TERMV = v2;
+                  heldFrom = cur;
+                  return EC.e;
+                }
+                const tl = cstTlLen(ctx), log = ctx._triviaLog?.length ?? 0, root = ctx._rootTriviaLog?.length ?? 0;
+                const scanEnd = skipTrivia(input, cur, ctx);
+                const scanTl = cstTlLen(ctx), scanLog = ctx._triviaLog?.length ?? 0, scanRoot = ctx._rootTriviaLog?.length ?? 0;
+                const v = kid(input, scanEnd, ctx);
+                if (v === FAIL) return -1;
+                TERMV = v;
+                heldFrom = cur;
+                heldTl = tl;
+                heldScanTl = scanTl;
+                heldLog = log;
+                heldScanLog = scanLog;
+                heldRoot = root;
+                heldScanRoot = scanRoot;
+                return scanEnd;
+              };
+            }
             if (holdsGap(code, k, base, n, i, NULLABLE)) {
               const kid = link(kidIp);
               return (input, cur, ctx) => {