@thomasfosterau/effect-parse 0.4.1 → 0.6.0

package/src/internal/compiler/registry.ts

@@ -11,15 +11,23 @@ import type { Fallback, Step } from "./closure.js"
 
 /** What was compiled for a parser and an input kind. */
 export interface Compiled {
-  /** The compiler actually used. */
-  readonly backend: "jit" | "closure" | undefined
+  /** The compiler actually used: `interpreted` when compilation failed. */
+  readonly backend: "wasm" | "jit" | "closure" | "interpreted"
   readonly step: Step | undefined
+  /**
+   * Whether `step` reports a call-stack overflow as a `TooDeep` failure
+   * itself, as `Stack.run` would (the JIT's generated entry does), so that
+   * it runs without that guard.
+   */
+  readonly guarded: boolean
   /** Parts of the grammar that run interpreted, and why. */
   readonly fallbacks: ReadonlyArray<Fallback>
   /** Why compilation failed, if it did (the parser then runs interpreted). */
   readonly error: unknown
   /** Why the JIT failed, if it did (the closure compiler is then used). */
   readonly jitError?: unknown
+  /** Why the WebAssembly compiler failed, if it did (the JIT is then used). */
+  readonly wasmError?: unknown
   /** The generated source, for the JIT. */
   readonly source?: string
 }

package/src/internal/compiler/search.ts

@@ -0,0 +1,68 @@
+/**
+ * Searching for the stop characters of `Token.takeTill` on string input
+ * (#75): a run is scanned a unit at a time for `SearchHead` units, then
+ * found with `indexOf`, which V8 runs much faster on long runs. Both
+ * compilers use these; the interpreter scans unit by unit.
+ */
+import * as Arr from "effect/Array"
+import type { State } from "../../Input.js"
+import type { CharSet } from "./sets.js"
+
+/**
+ * How many units a compiled `takeTill` tests one at a time before it
+ * searches with `indexOf` (twice as many for several stop characters, whose
+ * cached search costs more): short runs, most tokens, are faster scanned.
+ */
+export const SearchHead = 8
+
+/** The most stop characters a compiled `takeTill` searches for. */
+const MaxStops = 3
+
+/**
+ * The stop characters of a `takeTill` set, as UTF-16 units, when there are
+ * one to `MaxStops` of them, each a whole code point (not a surrogate).
+ */
+export const stopChars = (cs: CharSet): ReadonlyArray<number> | undefined => {
+  const ranges = cs.ranges
+  if (ranges === undefined || Arr.isReadonlyArrayEmpty(ranges) || ranges.length > MaxStops) return undefined
+  if (!ranges.every(([a, b]) => a === b && (a < 0xd800 || (a > 0xdfff && a <= 0xffff)))) return undefined
+  return ranges.map(([a]) => a)
+}
+
+/**
+ * The stop characters of one compiled `takeTill`, identifying its search site.
+ * The state holds, under this site, where each one next occurs (see
+ * `nextStop`).
+ */
+export class StopCache {
+  constructor(readonly chars: ReadonlyArray<string>) {}
+}
+
+/**
+ * The first index from `p` of any of `site.chars` in the input of `s`, or
+ * `s.end`. The state remembers, for each stop character `i`, the first
+ * index at or after `from` where it occurs (`-1` if none), as
+ * `[from, at]` at `2 * i` in `s.searches.get(site)`: successive runs over
+ * one input then pay a comparison per stop character instead of a search,
+ * and one that never occurs is searched for once.
+ */
+export const nextStop = (site: StopCache, s: State<string>, p: number): number => {
+  const searches = (s.searches ??= new Map())
+  let memo = searches.get(site)
+  if (memo === undefined) {
+    memo = site.chars.flatMap(() => [-1, -1])
+    searches.set(site, memo)
+  }
+  let best = s.end
+  for (let i = 0; i < site.chars.length; i++) {
+    const from = memo[2 * i]
+    let at = memo[2 * i + 1]
+    if (from < 0 || p < from || (at >= 0 && at < p)) {
+      at = s.input.indexOf(site.chars[i], p)
+      memo[2 * i] = p
+      memo[2 * i + 1] = at
+    }
+    if (at >= 0 && at < best) best = at
+  }
+  return best
+}

package/src/internal/compiler/sets.ts

@@ -7,6 +7,7 @@ import * as Order from "effect/Order"
 import * as Predicate from "effect/Predicate"
 import type { Encoding } from "../../Encoding.js"
 import { firstCodePoint } from "../text.js"
+import type { TokenRangeLike } from "../tokens.js"
 import { compile, compileAny, PredicateRanges } from "../tokens.js"
 
 /** Size of the membership table: every byte, and the Latin-1 code points. */
@@ -28,8 +29,7 @@ export const acceptTable = (set: CharSet, negate: boolean): Uint8Array => {
   return t
 }
 
-const isRange = (u: unknown): u is { readonly from: string | number; readonly to: string | number } =>
-  Predicate.isObjectOrArray(u) && (u as any)._tag === "TokenRange"
+const isRange = (u: unknown): u is TokenRangeLike => Predicate.isObjectOrArray(u) && Predicate.isTagged(u, "TokenRange")
 
 const toCode = (u: string | number): number => (Predicate.isNumber(u) ? u : firstCodePoint(u))
 
@@ -57,7 +57,11 @@ const rangesOf = (set: unknown): Array<[number, number]> | undefined => {
       return true
     }
     if (Predicate.isFunction(u)) {
-      const r = (u as any)[PredicateRanges] as ReadonlyArray<readonly [number, number]> | undefined
+      // SAFETY: `codePointPredicate` is the only writer of `PredicateRanges`, and it stores the
+      // predicate's sorted inclusive code point ranges there (or nothing)
+      const r = (u as { readonly [PredicateRanges]?: ReadonlyArray<readonly [number, number]> | undefined })[
+        PredicateRanges
+      ]
       if (r === undefined) return false
       for (const [a, b] of r) out.push([a, b])
       return true