parseman 0.26.0 → 0.26.1

package/dist/plugin/index.js

@@ -877,12 +877,159 @@ function keywords(words, opts = {}) {
   };
 }
 
+// src/recovery/scan.ts
+function probeAt(sentinel, input, pos, ctx) {
+  const s = {
+    _probe: ctx._probe,
+    _errors: ctx._errors,
+    _cstLeaves: ctx._cstLeaves,
+    _cstChildren: ctx._cstChildren,
+    _cstRawChildren: ctx._cstRawChildren,
+    _cstTriviaLog: ctx._cstTriviaLog,
+    _triviaLog: ctx._triviaLog,
+    _fields: ctx._fields,
+    _cstBuf: ctx._cstBuf,
+    _tolerant: ctx._tolerant,
+    _sync: ctx._sync
+  };
+  ctx._probe = void 0;
+  ctx._errors = void 0;
+  ctx._cstLeaves = void 0;
+  ctx._cstChildren = void 0;
+  ctx._cstRawChildren = void 0;
+  ctx._cstTriviaLog = void 0;
+  ctx._triviaLog = void 0;
+  ctx._fields = void 0;
+  ctx._cstBuf = void 0;
+  ctx._tolerant = void 0;
+  ctx._sync = void 0;
+  try {
+    return sentinel.parse(input, pos, ctx).ok;
+  } finally {
+    ctx._probe = s._probe;
+    ctx._errors = s._errors;
+    ctx._cstLeaves = s._cstLeaves;
+    ctx._cstChildren = s._cstChildren;
+    ctx._cstRawChildren = s._cstRawChildren;
+    ctx._cstTriviaLog = s._cstTriviaLog;
+    ctx._triviaLog = s._triviaLog;
+    ctx._fields = s._fields;
+    ctx._cstBuf = s._cstBuf;
+    ctx._tolerant = s._tolerant;
+    ctx._sync = s._sync;
+  }
+}
+function orSentinel(a, b) {
+  if (b === void 0) return a;
+  return {
+    _tag: "orSentinel",
+    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos, ctx) {
+      const ra = a.parse(input, pos, ctx);
+      if (ra.ok) return ra;
+      return b.parse(input, pos, ctx);
+    }
+  };
+}
+function firstSetSentinel(fs2) {
+  if (fs2.kind !== "ranges" || fs2.ranges.length === 0) return null;
+  const ranges = fs2.ranges;
+  return {
+    _tag: "firstSetSentinel",
+    _meta: { firstSet: fs2, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos) {
+      const code = pos < input.length ? input.codePointAt(pos) : void 0;
+      if (code !== void 0) {
+        for (const r of ranges) {
+          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
+        }
+      }
+      return { ok: false, expected: [], span: { start: pos, end: pos } };
+    }
+  };
+}
+function recoverScan(input, from, ctx, sync, expected) {
+  let scanPos = from;
+  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
+  const error = { _tag: "parseError", span: { start: from, end: scanPos }, expected };
+  ctx._errors?.push(error);
+  return { error, end: scanPos };
+}
+function matchesAt(sentinel, input, pos, ctx) {
+  return probeAt(sentinel, input, pos, ctx);
+}
+function captureError(ctx, error) {
+  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+}
+
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  const def = c._def;
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return def.words.map((w) => JSON.stringify(w));
+    case "label":
+      return [def.label];
+    case "choice":
+      return def.parsers.flatMap(deriveExpected);
+    case "sequence":
+      return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
+    case "node":
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "transform":
+    case "not":
+      return deriveExpected(def.parser);
+    case "lazy": {
+      const name = c._ruleName;
+      try {
+        return deriveExpected(def.thunk());
+      } catch {
+        return name ? [name] : [];
+      }
+    }
+    default:
+      return [];
+  }
+}
+function expect(combinator, label2) {
+  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "expect",
+    _meta: meta,
+    _def: { tag: "expect", parser: combinator, label: label2, expected },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (result.ok) return result;
+      const error = { _tag: "parseError", span: { start: pos, end: pos }, expected };
+      ctx._errors?.push(error);
+      if (ctx._tolerant) captureError(ctx, error);
+      return { ok: true, value: error, span: { start: pos, end: pos } };
+    }
+  };
+}
+
 // src/combinators/choice.ts
 function choice(...args) {
   const parsers = args.map((a) => "gate" in a ? a.combinator : a);
   const gates = args.map((a) => "gate" in a ? a.gate : null);
   const hasGates = gates.some((g) => g !== null);
-  const disjoint = !hasGates && areDisjoint(parsers.map((p) => p._meta.firstSet));
+  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
   let combined = { kind: "empty" };
   for (const p of parsers) combined = union(combined, p._meta.firstSet);
   const meta = {
@@ -921,17 +1068,21 @@ function choice(...args) {
       const expected = [];
       if (disjoint && pos < input.length) {
         const code = input.codePointAt(pos);
-        let parser2 = code < 128 ? asciiDispatch?.[code] ?? null : null;
-        if (!parser2) {
-          for (const p of parsers) {
-            if (inFirstSet(code, p._meta.firstSet)) {
-              parser2 = p;
+        let idx = code < 128 ? asciiDispatch[code] : -1;
+        if (idx < 0) {
+          for (let i = 0; i < parsers.length; i++) {
+            if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+              idx = i;
               break;
             }
           }
         }
-        if (parser2) {
-          const result = parser2.parse(input, pos, ctx);
+        if (idx >= 0) {
+          const gate = gates[idx];
+          if (gate && !gate(ctx.state)) {
+            return { ok: false, expected: deriveExpected(parsers[idx]), span: { start: pos, end: pos } };
+          }
+          const result = parsers[idx].parse(input, pos, ctx);
           if (result.ok) return result;
           expected.push(...result.expected);
           return { ok: false, expected, span: { start: pos, end: pos } };
@@ -1112,13 +1263,13 @@ function areDisjoint(sets) {
   return true;
 }
 function buildAsciiDispatch(parsers) {
-  const table = Array(128).fill(null);
-  for (const parser2 of parsers) {
-    const fs2 = parser2._meta.firstSet;
+  const table = Array(128).fill(-1);
+  for (let i = 0; i < parsers.length; i++) {
+    const fs2 = parsers[i]._meta.firstSet;
     if (fs2.kind !== "ranges") continue;
     for (const { lo, hi } of fs2.ranges) {
       for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
-        table[code] = parser2;
+        table[code] = i;
       }
     }
   }
@@ -1500,93 +1651,6 @@ function scanBlockComment(input, cur) {
   return close === -1 ? cur : close + 2;
 }
 
-// src/recovery/scan.ts
-function probeAt(sentinel, input, pos, ctx) {
-  const s = {
-    _probe: ctx._probe,
-    _errors: ctx._errors,
-    _cstLeaves: ctx._cstLeaves,
-    _cstChildren: ctx._cstChildren,
-    _cstRawChildren: ctx._cstRawChildren,
-    _cstTriviaLog: ctx._cstTriviaLog,
-    _triviaLog: ctx._triviaLog,
-    _fields: ctx._fields,
-    _cstBuf: ctx._cstBuf,
-    _tolerant: ctx._tolerant,
-    _sync: ctx._sync
-  };
-  ctx._probe = void 0;
-  ctx._errors = void 0;
-  ctx._cstLeaves = void 0;
-  ctx._cstChildren = void 0;
-  ctx._cstRawChildren = void 0;
-  ctx._cstTriviaLog = void 0;
-  ctx._triviaLog = void 0;
-  ctx._fields = void 0;
-  ctx._cstBuf = void 0;
-  ctx._tolerant = void 0;
-  ctx._sync = void 0;
-  try {
-    return sentinel.parse(input, pos, ctx).ok;
-  } finally {
-    ctx._probe = s._probe;
-    ctx._errors = s._errors;
-    ctx._cstLeaves = s._cstLeaves;
-    ctx._cstChildren = s._cstChildren;
-    ctx._cstRawChildren = s._cstRawChildren;
-    ctx._cstTriviaLog = s._cstTriviaLog;
-    ctx._triviaLog = s._triviaLog;
-    ctx._fields = s._fields;
-    ctx._cstBuf = s._cstBuf;
-    ctx._tolerant = s._tolerant;
-    ctx._sync = s._sync;
-  }
-}
-function orSentinel(a, b) {
-  if (b === void 0) return a;
-  return {
-    _tag: "orSentinel",
-    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos, ctx) {
-      const ra = a.parse(input, pos, ctx);
-      if (ra.ok) return ra;
-      return b.parse(input, pos, ctx);
-    }
-  };
-}
-function firstSetSentinel(fs2) {
-  if (fs2.kind !== "ranges" || fs2.ranges.length === 0) return null;
-  const ranges = fs2.ranges;
-  return {
-    _tag: "firstSetSentinel",
-    _meta: { firstSet: fs2, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos) {
-      const code = pos < input.length ? input.codePointAt(pos) : void 0;
-      if (code !== void 0) {
-        for (const r of ranges) {
-          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
-        }
-      }
-      return { ok: false, expected: [], span: { start: pos, end: pos } };
-    }
-  };
-}
-function recoverScan(input, from, ctx, sync, expected) {
-  let scanPos = from;
-  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
-  const error = { _tag: "parseError", span: { start: from, end: scanPos }, expected };
-  ctx._errors?.push(error);
-  return { error, end: scanPos };
-}
-function matchesAt(sentinel, input, pos, ctx) {
-  return probeAt(sentinel, input, pos, ctx);
-}
-function captureError(ctx, error) {
-  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
-}
-
 // src/combinators/sequence.ts
 function sequence(...parsers) {
   const meta = {
@@ -1688,66 +1752,6 @@ function sequence(...parsers) {
   };
 }
 
-// src/combinators/expect.ts
-function deriveExpected(c) {
-  const def = c._def;
-  switch (def.tag) {
-    case "literal":
-      return [JSON.stringify(def.value)];
-    case "regex":
-      return [`/${def.source}/`];
-    case "keywords":
-      return def.words.map((w) => JSON.stringify(w));
-    case "label":
-      return [def.label];
-    case "choice":
-      return def.parsers.flatMap(deriveExpected);
-    case "sequence":
-      return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
-    case "node":
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "transform":
-    case "not":
-      return deriveExpected(def.parser);
-    case "lazy": {
-      const name = c._ruleName;
-      try {
-        return deriveExpected(def.thunk());
-      } catch {
-        return name ? [name] : [];
-      }
-    }
-    default:
-      return [];
-  }
-}
-function expect(combinator, label2) {
-  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "expect",
-    _meta: meta,
-    _def: { tag: "expect", parser: combinator, label: label2, expected },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (result.ok) return result;
-      const error = { _tag: "parseError", span: { start: pos, end: pos }, expected };
-      ctx._errors?.push(error);
-      if (ctx._tolerant) captureError(ctx, error);
-      return { ok: true, value: error, span: { start: pos, end: pos } };
-    }
-  };
-}
-
 // src/combinators/repeat.ts
 function repItem(combinator, input, cur, ctx) {
   const mark = saveTriviaMark(ctx);
@@ -4524,6 +4528,21 @@ function emitDisjointArm(p, ctx, pos, valV, endV) {
     `${ind(ctx)}${endV} = ${endVar}`
   ];
 }
+function emitDisjointArmGated(def, i, ctx, pos, valV, endV) {
+  const p = def.parsers[i];
+  const gate = def.gates[i];
+  if (!gate) return emitDisjointArm(p, ctx, pos, valV, endV);
+  const gateIdx = ctx.mapFns.length;
+  ctx.mapFns.push(gate);
+  ctx.mapFnSrcs.push(def.gateSrcs?.[i] ?? null);
+  const gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`;
+  const stmts = [`${ind(ctx)}if (${gateCond}) {`];
+  ctx.indent++;
+  stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV));
+  ctx.indent--;
+  stmts.push(`${ind(ctx)}} else { ${failArrBody(ctx, deriveExpectedArr([p]), pos)} }`);
+  return stmts;
+}
 function emitChoice(def, ctx, pos) {
   const allExpected = deriveExpectedArr(def.parsers);
   if (def.disjoint) {
@@ -4539,12 +4558,11 @@ function emitChoice(def, ctx, pos) {
       stmts.push(`${ind(ctx)}switch (${codeV}) {`);
       ctx.indent++;
       for (let i = 0; i < def.parsers.length; i++) {
-        const p = def.parsers[i];
         for (const cp of plan.cases[i]) stmts.push(`${ind(ctx)}case ${cp}:`);
         stmts.push(`${ind(ctx)}{`);
         ctx.indent++;
         stmts.push(
-          ...emitDisjointArm(p, ctx, pos, valV, endV),
+          ...emitDisjointArmGated(def, i, ctx, pos, valV, endV),
           `${ind(ctx)}break`
         );
         ctx.indent--;
@@ -4556,13 +4574,14 @@ function emitChoice(def, ctx, pos) {
       return { stmts, valueVar: valV, endVar: endV };
     }
     let first = true;
-    for (const p of def.parsers) {
+    for (let i = 0; i < def.parsers.length; i++) {
+      const p = def.parsers[i];
       const cond = firstSetCond(codeV, p._meta.firstSet);
       const kw = first ? "if" : "else if";
       first = false;
       stmts.push(`${ind(ctx)}${kw} (${cond}) {`);
       ctx.indent++;
-      stmts.push(...emitDisjointArm(p, ctx, pos, valV, endV));
+      stmts.push(...emitDisjointArmGated(def, i, ctx, pos, valV, endV));
       ctx.indent--;
       stmts.push(`${ind(ctx)}}`);
     }