parseman 0.55.3 → 0.56.0

package/src/table/line-scan.ts

@@ -0,0 +1,19 @@
+import type { Combinator } from '../types.ts'
+import type { ScanSpec, SubtreeRef } from './program.ts'
+import { columns, lines } from '../combinators/lines.ts'
+
+/**
+ * Rebuild a `lines()` (kind 2) or `columns()` (kind 3) scan spec as the
+ * combinator it was constructed as, its subtrees bound to the table's pieces.
+ * Both drivers run the result through its own `parse`, as they do `scanTo`.
+ */
+export function rebuildLineScan(s: ScanSpec, subtree: (r: SubtreeRef) => Combinator<unknown>): Combinator<unknown> | undefined {
+  if (s.kind === 2) {
+    return lines(subtree(s.prefix!), subtree(s.body!), {
+      ...(s.first === undefined ? {} : { first: subtree(s.first) }),
+      ...(s.lazy === undefined ? {} : { lazy: subtree(s.lazy) }),
+    }) as Combinator<unknown>
+  }
+  if (s.kind === 3) return columns(s.n!) as Combinator<unknown>
+  return undefined
+}

package/src/table/program.ts

@@ -241,13 +241,13 @@ export type SubtreeRef = readonly [ip: number, cls: number]
 /**
  * A scanning construct as its CONSTRUCTOR ARGUMENTS.
  *
- * `kind` 0 is `scanTo`, 1 is `balanced`. `flags` bit 0 = `raw`, bit 1 = `orEOF`
+ * `kind` 0 is `scanTo`, 1 is `balanced`, 2 is `lines`, 3 is `columns`. `flags` bit 0 = `raw`, bit 1 = `orEOF`
  * (scanTo), bit 2 = `strict` (balanced). `sent` is the sentinel's literal text
  * when it is a `literal()`, so the rebuilt scan reports the same expected set as
  * the interpreter, and `null` otherwise (which reports `"sentinel"`).
  */
 export type ScanSpec = {
-  readonly kind: 0 | 1
+  readonly kind: 0 | 1 | 2 | 3
   readonly flags: number
   readonly skip: readonly SubtreeRef[]
   readonly sentinel?: SubtreeRef
@@ -256,6 +256,21 @@ export type ScanSpec = {
   readonly sent?: string | null
   readonly open?: string
   readonly close?: string
+  /** `lines()` (kind 2): the continuation prefix, the body, and the optional first-line prefix and lazy check. */
+  readonly prefix?: SubtreeRef
+  readonly body?: SubtreeRef
+  readonly first?: SubtreeRef
+  readonly lazy?: SubtreeRef
+  /** `columns()` (kind 3): the column count. */
+  readonly n?: number
+}
+
+/** Every subtree a scan spec references, which the table links as roots. */
+export function scanRefs(s: ScanSpec): SubtreeRef[] {
+  const refs: SubtreeRef[] = []
+  for (const r of [s.sentinel, s.recoverAt, s.stopAt, s.prefix, s.body, s.first, s.lazy]) if (r !== undefined) refs.push(r)
+  refs.push(...s.skip)
+  return refs
 }
 
 /** A trivia combinator as data. `arms` empty means a plain `trivia(regex)`. */

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { LineView } from './combinators/lines.ts'
 import type { LabeledTriviaSpec } from './cst/trivia-kinds.ts'
 
 export type Span = {
@@ -113,6 +114,11 @@ export type ParserDef =
   // pre-ambient raw byte-walk.
   | { tag: 'scanTo';   sentinel: Combinator<unknown>; skip: Combinator<unknown>[]; raw: boolean; orEOF: boolean; recoverAt?: Combinator<unknown>; stopAt?: Combinator<unknown> }
   | { tag: 'keywords'; words: readonly string[]; caseInsensitive: boolean; boundary: string | undefined }
+  // `lines()`: `body` parses a run of lines with `prefix` (`first` on the first
+  // line) removed from each; `lazy` admits a line the prefix does not match.
+  | { tag: 'lines';    prefix: Combinator<unknown>; body: Combinator<unknown>; first?: Combinator<unknown>; lazy?: Combinator<unknown> }
+  // `columns(n)`: n columns of indentation, a tab reaching the next stop of four.
+  | { tag: 'columns';  n: number }
   | { tag: 'unknown' }
 
 export type Combinator<T> = {
@@ -280,6 +286,14 @@ export type ParseContext = {
   trackLines: boolean
   /** Grammar-author-provided state, scoped with withCtx() and read in guard(). */
   state?: unknown
+  /**
+   * Inside a `lines()` body, the run's lines: where each line's content sits in
+   * the body's input and in the run's own input, and the column it starts at.
+   * Undefined outside any run.
+   */
+  lineView?: LineView | undefined
+  /** Framework-internal: where `columns()` last stopped inside a tab, for `lines()`. */
+  _columnsSplit?: { at: number; split: number } | undefined
   /**
    * Mode host (RULE_ABI_PLAN §7): when set, a linkable/fused grammar's `node()`
    * rules build via `build(type, children, fields, span, rawChildren, triviaLog, state)`
@@ -554,7 +568,11 @@ export type GatedArm<T = unknown> = {
  * deleted.
  */
 export type CompiledParser<T> = {
-  parse(input: string, pos?: number): ParseResult<T>
+  /**
+   * Parse from `pos`. With `ctx`, the parse runs in that context, as a combinator's
+   * own `parse(input, pos, ctx)` does; without it, in a fresh one.
+   */
+  parse(input: string, pos?: number, ctx?: ParseContext): ParseResult<T>
   /** Like parse(), but with a caller-supplied ParseContext (e.g. `_triviaLog` for CST grammars). */
   parseWithContext(input: string, ctx: ParseContext, pos?: number): ParseResult<T>
   /**

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.55.3'
+export const PARSEMAN_VERSION = '0.56.0'