parseman 0.40.0 → 0.42.0

package/dist/language-service/index.js

@@ -1,3 +1,47 @@
+// src/line-index.ts
+function recordLineRange(index, input, start, end) {
+  const lineStarts = index.lineStarts;
+  for (let i = start; i < end; i++) {
+    if (input.charCodeAt(i) === 10) lineStarts.push(i + 1);
+  }
+}
+function recordLineRangeFromContext(ctx, input, _startHint, end) {
+  if (!ctx.trackLines) return;
+  const from = ctx._lineScannedTo ?? 0;
+  if (end <= from) return;
+  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : void 0);
+  if (!index) return;
+  recordLineRange(index, input, from, end);
+  ctx._lineScannedTo = end;
+}
+function offsetToLineCol(index, offset) {
+  const { lineStarts } = index;
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lineStarts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return { line: lo + 1, col: offset - lineStarts[lo] + 1 };
+}
+function annotateSpan(span, index) {
+  const s = offsetToLineCol(index, span.start);
+  const e = offsetToLineCol(index, span.end);
+  return {
+    ...span,
+    startLine: s.line,
+    startColumn: s.col,
+    endLine: e.line,
+    endColumn: e.col
+  };
+}
+function annotateSpanFromLineContext(span, ctx) {
+  if (!ctx.trackLines) return span;
+  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : void 0);
+  return index ? annotateSpan(span, index) : span;
+}
+
 // src/cst/capture-buffer.ts
 function cstCaptureActive(ctx) {
   return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
@@ -98,7 +142,9 @@ function firstSetSentinel(fs) {
 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 };
+  const span = { start: from, end: scanPos };
+  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
+  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
   ctx._errors?.push(error);
   return { error, end: scanPos };
 }
@@ -110,6 +156,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");
@@ -129,6 +319,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(
@@ -141,6 +337,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",
@@ -152,7 +349,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 } : {},
@@ -175,6 +372,8 @@ function runOnce(entry, input, options, phase, profileState) {
     expected: r.ok ? [] : r.expected ?? [],
     errors,
     triviaLog,
+    ...triviaKindLabels === void 0 ? {} : { triviaKindLabels },
+    triviaMap: buildRootTriviaIndex(triviaLog, triviaKindLabels),
     unconsumedFrom
   };
 }
@@ -238,7 +437,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");
 
@@ -252,7 +451,7 @@ function normalizeCstCollapse(collapse) {
   return typeof collapse === "function" ? collapse : void 0;
 }
 function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] };
+  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children] };
 }
 function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
   if (typeof typeOrOptions === "string") {