parseman 0.40.0 → 0.41.0

package/dist/language-service/index.cjs

@@ -136,6 +136,150 @@ function captureError(ctx, error) {
 }
 var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
 
+// src/cst/trivia-entries.ts
+var EMPTY_INDICES = Object.freeze([]);
+var EMPTY_GAPS = Object.freeze([]);
+function entryOffset(i, stride) {
+  return i * stride;
+}
+function triviaEntries(log, labels, opts) {
+  const baseStride = opts?.nodeLog ? 3 : 2;
+  const stride = labels ? baseStride + 1 : baseStride;
+  const length = Math.floor(log.length / stride);
+  return {
+    length,
+    labels,
+    stride,
+    start(i) {
+      return log[entryOffset(i, stride)];
+    },
+    end(i) {
+      return log[entryOffset(i, stride) + 1];
+    },
+    insertIndex(i) {
+      return opts?.nodeLog ? log[entryOffset(i, stride) + 2] : void 0;
+    },
+    kindIndex(i) {
+      if (!labels) return void 0;
+      return log[entryOffset(i, stride) + baseStride];
+    },
+    kind(i) {
+      const ki = labels ? log[entryOffset(i, stride) + baseStride] : void 0;
+      return ki !== void 0 ? labels[ki] : void 0;
+    },
+    text(i, input) {
+      const s = log[entryOffset(i, stride)];
+      const e = log[entryOffset(i, stride) + 1];
+      return input.slice(s, e);
+    }
+  };
+}
+function appendEntryRange(map, key, first, last) {
+  let indices = map.get(key);
+  if (!indices) {
+    indices = [];
+    map.set(key, indices);
+  }
+  for (let i = first; i <= last; i++) indices.push(i);
+}
+function buildGap(entries, start, end, first, last) {
+  const entryIndices = [];
+  for (let i = first; i <= last; i++) entryIndices.push(i);
+  return {
+    start,
+    end,
+    entryIndices,
+    hasKind(kind) {
+      for (const i of entryIndices) {
+        if (entries.kind(i) === kind) return true;
+      }
+      return false;
+    },
+    text(input) {
+      return input.slice(start, end);
+    }
+  };
+}
+function buildRootMaps(entries) {
+  const before = /* @__PURE__ */ new Map();
+  const after = /* @__PURE__ */ new Map();
+  const beforeGaps = /* @__PURE__ */ new Map();
+  const afterGaps = /* @__PURE__ */ new Map();
+  const gaps = [];
+  if (entries.length === 0) return { before, after, beforeGaps, afterGaps, gaps };
+  const appendGap = (first2, last, start2, end2) => {
+    const gap = buildGap(entries, start2, end2, first2, last);
+    gaps.push(gap);
+    afterGaps.set(start2, gap);
+    beforeGaps.set(end2, gap);
+    appendEntryRange(after, start2, first2, last);
+    appendEntryRange(before, end2, first2, last);
+  };
+  let first = 0;
+  let start = entries.start(0);
+  let end = entries.end(0);
+  for (let i = 1; i < entries.length; i++) {
+    const nextStart = entries.start(i);
+    const nextEnd = entries.end(i);
+    if (nextStart === end) {
+      end = nextEnd;
+      continue;
+    }
+    appendGap(first, i - 1, start, end);
+    first = i;
+    start = nextStart;
+    end = nextEnd;
+  }
+  appendGap(first, entries.length - 1, start, end);
+  return { before, after, beforeGaps, afterGaps, gaps };
+}
+function buildRootTriviaIndex(log, labels) {
+  const entries = triviaEntries(log, labels);
+  let maps;
+  const getMaps = () => {
+    maps ??= buildRootMaps(entries);
+    return maps;
+  };
+  return {
+    entries,
+    labels,
+    get before() {
+      return getMaps().before;
+    },
+    get after() {
+      return getMaps().after;
+    },
+    entryIndicesBefore(offset) {
+      return getMaps().before.get(offset) ?? EMPTY_INDICES;
+    },
+    entryIndicesAfter(offset) {
+      return getMaps().after.get(offset) ?? EMPTY_INDICES;
+    },
+    gapBefore(offset) {
+      return getMaps().beforeGaps.get(offset);
+    },
+    gapAfter(offset) {
+      return getMaps().afterGaps.get(offset);
+    },
+    gaps() {
+      return getMaps().gaps;
+    },
+    gapsWithKind(kind) {
+      const kinds = typeof kind === "string" ? [kind] : kind;
+      const matches2 = [];
+      for (const gap of getMaps().gaps) {
+        for (const k of kinds) {
+          if (gap.hasKind(k)) {
+            matches2.push(gap);
+            break;
+          }
+        }
+      }
+      return matches2.length === 0 ? EMPTY_GAPS : matches2;
+    }
+  };
+}
+
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
 var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
@@ -155,6 +299,12 @@ function assertHostModeCompatible(mode, build, hostBranchElided = true) {
 
 // src/functional/run.ts
 var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function triviaKindLabelsFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.triviaKindLabels;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return r._meta.triviaKindLabels ?? grammarTrivia?._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+}
 function runOnce(entry, input, options, phase, profileState) {
   if (typeof entry !== "function" && typeof entry?.parse !== "function") {
     throw new TypeError(
@@ -167,6 +317,7 @@ function runOnce(entry, input, options, phase, profileState) {
   const skipGlobalSinks = phase === "recognizer" || phase === "capture";
   const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
   const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
+  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
   const stamped = entry;
   assertHostModeCompatible(
     typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
@@ -178,7 +329,7 @@ function runOnce(entry, input, options, phase, profileState) {
     ...skipGlobalSinks ? { _pmProfile: profile } : { _triviaLog: triviaLog, _errors: errors, ...profile === void 0 ? {} : { _pmProfile: profile } },
     build: options.build,
     state: options.state,
-    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...triviaKindLabels ? { triviaKindLabels } : {} } : triviaKindLabels ? { triviaKindLabels } : {},
     ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
     ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {},
     ...options.tolerant ? { _tolerant: true, _rec: REC } : {},
@@ -201,6 +352,8 @@ function runOnce(entry, input, options, phase, profileState) {
     expected: r.ok ? [] : r.expected ?? [],
     errors,
     triviaLog,
+    ...triviaKindLabels === void 0 ? {} : { triviaKindLabels },
+    triviaMap: buildRootTriviaIndex(triviaLog, triviaKindLabels),
     unconsumedFrom
   };
 }
@@ -264,7 +417,7 @@ var META = new Set("()[]{}*+?|^$.".split(""));
 var CAP_RECORD = [
   `  if (_cap && _e > _pos) {`,
   `    if (_ctx._triviaLog !== undefined) _ctx._triviaLog.push(_pos, _e)`,
-  `    if (_ctx._cstTriviaLog !== undefined && _ctx.captureTrivia) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
+  `    if (_cap === 1 && _ctx._cstTriviaLog !== undefined && _ctx.captureTrivia) _ctx._cstTriviaLog.push(_pos, _e, _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0)`,
   `  }`
 ].join("\n");