parseman 0.29.0 → 0.30.0

package/dist/plugin/index.cjs

@@ -61,6 +61,15 @@ function intersects(a, b) {
 function fromChar(code) {
   return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
 }
+function startsFirstSet(combinator, input, pos) {
+  const fs2 = combinator._meta.firstSet;
+  if (fs2.kind === "any") return true;
+  if (fs2.kind === "empty") return false;
+  const code = input.codePointAt(pos);
+  if (code === void 0) return false;
+  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
 function fromRange(lo, hi) {
   return { kind: "ranges", ranges: [{ lo, hi }] };
 }
@@ -1020,6 +1029,17 @@ function deriveExpected(c) {
       return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
     case "attempt":
       return deriveExpected(def.parser);
+    // Delegating wrappers whose first-token failure is their inner parser's — must
+    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
+    // node, which reads this) names the real expected token, not the wrapper tag.
+    case "field":
+    case "withCtx":
+    case "recover":
+      return deriveExpected(def.parser);
+    case "skip":
+      return deriveExpected(def.main);
+    case "expect":
+      return def.expected;
     case "node":
     case "grammar":
     case "trivia":
@@ -1080,7 +1100,7 @@ function choice(...args) {
     disjoint
   };
   const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && strategy?.tag === "firstMatch" ? computeAutoNot(parsers) : parsers.map(() => null);
+  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
   let greedyLitMap = null;
   let sortedParsers = null;
   const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
@@ -1206,8 +1226,47 @@ function detectStrategy(parsers) {
     );
     return { tag: "literalsLongestFirst", sortedIndices };
   }
+  const shared = detectSharedPrefix(parsers);
+  if (shared !== null) return shared;
   return { tag: "firstMatch" };
 }
+function bareLeadingTermKey(term) {
+  const d = term._def;
+  if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
+  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
+  return null;
+}
+function detectSharedPrefix(parsers) {
+  if (parsers.length < 2) return null;
+  let key = null;
+  let prefix = null;
+  const members = [];
+  for (let i = 0; i < parsers.length; i++) {
+    const term0 = leadingTermOfArm(parsers[i]);
+    if (term0 === null) return null;
+    const k = bareLeadingTermKey(term0);
+    if (k === null) return null;
+    if (key === null) {
+      key = k;
+      prefix = term0;
+    } else if (k !== key) return null;
+    members.push(i);
+  }
+  if (prefix === null || members.length < 2) return null;
+  return { tag: "sharedPrefix", prefix, members };
+}
+function leadingTermOfArm(arm) {
+  let d = arm._def;
+  for (; ; ) {
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      d = d.parser._def;
+      continue;
+    }
+    break;
+  }
+  if (d.tag !== "sequence" || d.parsers.length < 2) return null;
+  return d.parsers[0];
+}
 function computeAutoNot(parsers) {
   return parsers.map((p, i) => {
     const litVal = getCoreLiteralValue(p);
@@ -1801,11 +1860,20 @@ function sequence(...parsers) {
 
 // src/combinators/attempt.ts
 function attempt(parser2) {
+  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
+  let failExpected;
   return {
     _tag: "attempt",
     _meta: parser2._meta,
     _def: { tag: "attempt", parser: parser2 },
     parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(parser2);
+          failExpected = e.length > 0 ? e : [parser2._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
       const mark = saveCstMark(ctx);
       const log = ctx._triviaLog?.length;
       const result = parser2.parse(input, pos, ctx);
@@ -1818,7 +1886,7 @@ function attempt(parser2) {
 }
 
 // src/combinators/repeat.ts
-function repItem(combinator, input, cur, ctx) {
+function repItem(combinator, input, cur, ctx, guardable) {
   const mark = saveTriviaMark(ctx);
   let pos = cur;
   if (ctx.trivia) {
@@ -1834,6 +1902,10 @@ function repItem(combinator, input, cur, ctx) {
     rollbackTrivia(ctx, mark);
     return "stop";
   }
+  if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+    rollbackTrivia(ctx, mark);
+    return "stop";
+  }
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
     rollbackTrivia(ctx, mark);
@@ -1853,6 +1925,7 @@ function many(combinator) {
   };
   const def = { tag: "many", parser: combinator, min: 0 };
   let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   return {
     _tag: "many",
     _meta: meta,
@@ -1861,7 +1934,7 @@ function many(combinator) {
       const values = def.valueUnused ? void 0 : [];
       let cur = pos;
       while (cur < input.length) {
-        const item = repItem(combinator, input, cur, ctx);
+        const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
           const sync = ctx._tolerant ? ctx._sync : void 0;
@@ -1889,6 +1962,7 @@ function oneOrMore(combinator) {
   };
   const def = { tag: "oneOrMore", parser: combinator, min: 1 };
   let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   return {
     _tag: "oneOrMore",
     _meta: meta,
@@ -1899,7 +1973,7 @@ function oneOrMore(combinator) {
       const values = def.valueUnused ? void 0 : [first.value];
       let cur = first.span.end;
       while (cur < input.length) {
-        const item = repItem(combinator, input, cur, ctx);
+        const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
           const sync = ctx._tolerant ? ctx._sync : void 0;
@@ -1942,15 +2016,6 @@ function optional(combinator) {
     }
   };
 }
-function startsFirstSet(combinator, input, pos) {
-  const fs2 = combinator._meta.firstSet;
-  if (fs2.kind === "any") return true;
-  if (fs2.kind === "empty") return false;
-  const code = input.codePointAt(pos);
-  if (code === void 0) return false;
-  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
-  return false;
-}
 function sepBy(combinator, separator) {
   const meta = {
     firstSet: combinator._meta.firstSet,
@@ -2447,11 +2512,20 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : true);
   const clonesState = build ? buildReadsState(def) : true;
   const capturesFields = parserHasOwnFields(combinator) && (build ? buildReadsFields(def) : true);
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  let failExpected;
   return {
     _tag: "node",
     _meta: meta,
     _def: def,
     parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(combinator);
+          failExpected = e.length > 0 ? e : [combinator._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
       const saved = beginCstNodeCapture(ctx);
       const savedFields = ctx._fields;
       ctx._fields = capturesFields ? [] : void 0;
@@ -4447,6 +4521,7 @@ var SWITCH_RANGE_LIMIT = 4;
 var SWITCH_MAX_CASES = 48;
 var SWITCH_MIN_CASES = 3;
 var _forceDisjointIf = false;
+var _forceNoSharedPrefix = false;
 function planDisjointDispatch(parsers) {
   const cases = [];
   let total = 0;
@@ -5082,7 +5157,7 @@ function emitLiteralsLongestFirst(def, sortedIndices, allExpected, ctx, pos, cov
   stmts.push(...emitElseFail(ctx, failArrBody(ctx, allExpected, pos)));
   return { stmts, valueVar: valV, endVar: endV };
 }
-function emitFirstMatch(def, ctx, pos, coverageBase) {
+function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
   const resValV = v(ctx, "_crv");
   const resEndV = v(ctx, "_cre");
   const resOkV = v(ctx, "_crok");
@@ -5096,6 +5171,7 @@ function emitFirstMatch(def, ctx, pos, coverageBase) {
     ...autoRejectedV === void 0 ? [] : [`${ind0}const ${autoRejectedV} = []`],
     `${ind0}const ${codeV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`
   ];
+  if (preStmts) stmts.push(...preStmts);
   for (let i = 0; i < def.parsers.length; i++) {
     const p = def.parsers[i];
     const gate = def.gates[i];
@@ -5103,11 +5179,12 @@ function emitFirstMatch(def, ctx, pos, coverageBase) {
     const atStart = failsAtStart(p);
     const staticFx = armStaticExpected(ctx, p);
     const deferRuleName = ctx.deferFirstSetRefs ? p._ruleName : void 0;
-    const fsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : (() => {
+    const baseFsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : (() => {
       if (p._meta.firstSet.kind !== "any" || matchesEmpty(p)) return null;
       const deep = firstSetOf(p);
       return deep.kind === "ranges" ? firstSetCond(codeV, deep) : null;
     })();
+    const fsGuard = armGuardPrefix === void 0 ? baseFsGuard : baseFsGuard === null ? armGuardPrefix : `${armGuardPrefix} && (${baseFsGuard})`;
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
@@ -5176,11 +5253,64 @@ function emitFirstMatch(def, ctx, pos, coverageBase) {
   stmts.push(...emitIfFail(ctx, `!${resOkV}`, failArrBody(ctx, concatExpr, pos, false)));
   return { stmts, valueVar: resValV, endVar: resEndV };
 }
+function emitsAsNamedFn(p, ctx) {
+  if (p._def.tag === "lazy") return true;
+  if (ctx.ruleNames?.has(p)) return true;
+  if (ctx.namedParsers.has(p)) return true;
+  const usage = ctx.lazyUsage;
+  return !!usage && !ctx.noHoist && !ctx.capAsTrivia && isHoistableTag(p._def.tag) && (usage.counts.get(p) ?? 0) > 1 && (usage.sizes.get(p) ?? 0) >= HOIST_MIN_SUBTREE;
+}
+function armReplayInScope(arm, ctx) {
+  let p = arm;
+  for (; ; ) {
+    if (emitsAsNamedFn(p, ctx)) return false;
+    const d = p._def;
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      p = d.parser;
+      continue;
+    }
+    return d.tag === "sequence";
+  }
+}
+function emitSharedPrefix(def, strategy, ctx, pos) {
+  const { prefix, members } = strategy;
+  const savedCapturing = ctx.capturing;
+  ctx.capturing = false;
+  const pfx = emitFallible(prefix, ctx, pos, false);
+  ctx.capturing = savedCapturing;
+  const map = ctx.replayPrefix ??= /* @__PURE__ */ new Map();
+  const keys = [];
+  for (const i of members) {
+    const term0 = leadingTermOfArm(def.parsers[i]);
+    if (term0 === null) continue;
+    map.set(term0, { valVar: pfx.valVar, endVar: pfx.endVar });
+    keys.push(term0);
+  }
+  const r = emitFirstMatch(def, ctx, pos, void 0, pfx.stmts, pfx.okVar);
+  for (const k of keys) map.delete(k);
+  return r;
+}
+function emitReplayPrefixLeaf(ctx, pos, replay) {
+  const vv = v(ctx);
+  return {
+    stmts: [
+      `${ind(ctx)}const ${vv} = ${replay.valVar}`,
+      ...emitLeafCapture(ctx, vv, pos, replay.endVar)
+    ],
+    valueVar: vv,
+    endVar: replay.endVar
+  };
+}
 function emitNonDisjoint(def, strategy, allExpected, ctx, pos, coverageBase) {
   if (strategy.tag === "greedyClassify")
     return emitGreedyClassify(def, strategy.superIndex, ctx, pos, coverageBase);
   if (strategy.tag === "literalsLongestFirst")
     return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos, coverageBase);
+  if (strategy.tag === "sharedPrefix") {
+    if (!_forceNoSharedPrefix && coverageBase === void 0 && !ctx.recovery && strategy.members.every((i) => armReplayInScope(def.parsers[i], ctx)))
+      return emitSharedPrefix(def, strategy, ctx, pos);
+    return emitFirstMatch(def, ctx, pos, coverageBase);
+  }
   return emitFirstMatch(def, ctx, pos, coverageBase);
 }
 function pushMapFn(ctx, fn, src) {
@@ -5894,6 +6024,8 @@ function emitExpect(def, ctx, pos) {
   return { stmts, valueVar: valVar, endVar };
 }
 function emit(p, ctx, pos) {
+  const replay = ctx.replayPrefix?.get(p);
+  if (replay !== void 0) return emitReplayPrefixLeaf(ctx, pos, replay);
   const dispatch = (emissionPos = pos) => {
     const savedRule = ctx.activeCoverageRuleId;
     const rule = ctx.coverage?.plan.rules.get(p);