parseman 0.59.0 → 0.59.2

package/src/table/scan-shapes.ts

@@ -94,7 +94,7 @@ export type ScanShape =
   | { kind: 'alt'; arms: ScanShape[]; disjoint: boolean; firsts: Array<CharSet | null> }
 
 /** Backslash (`\`) code point — the escape lead char in string shapes. */
-export const BACKSLASH = 92
+const BACKSLASH = 92
 
 const META = new Set('()[]{}*+?|^$.'.split(''))
 
@@ -1137,15 +1137,6 @@ function caseFoldLiteralOrAlt(source: string): ScanShape | null {
   return { kind: 'alt', arms: litArms, disjoint: false, firsts: litArms.map(() => null) }
 }
 
-/**
- * `PARSEMAN_SCANTO=indexof` swaps the single-stop-char `until` scan loop for
- * `String.prototype.indexOf`. Defaults OFF so a baseline build is provably
- * byte-identical to the unmodified compiler, which is what makes the A/B a
- * toggle rather than two different compilers (docs/design/derived-tokenization.md
- * §16.3: the gate is a byte-identical parse tree against a toggled baseline).
- */
-const scanToIndexOfEnabled = (): boolean => process.env.PARSEMAN_SCANTO === 'indexof'
-
 export const classCond = (cVar: string, ranges: Array<[number, number]>): string =>
   ranges
     .map(([lo, hi]) => (lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`))
@@ -1162,10 +1153,10 @@ export const litCond = (base: string, cps: number[], firstVar?: string): string
     .join(' && ')
 
 /** Line-terminator code points `.` does not match (`\n \r \u2028 \u2029`). */
-export const LINE_TERMINATORS = [10, 13, 8232, 8233] as const
+const LINE_TERMINATORS = [10, 13, 8232, 8233] as const
 
 /** The body-stop chars that abort a string match (excluded set minus quote/backslash). */
-export function stringHardStop(
+function stringHardStop(
   shape: Extract<ScanShape, { kind: 'string' }>,
 ): Array<[number, number]> {
   return shape.excluded.filter(
@@ -1467,24 +1458,12 @@ export function emitShapeMatch(
     const openChk = openLen === 1
       ? `${codeAt(start, firstChar)} === ${shape.open[0]}`
       : litCond(start, shape.open, firstChar)
-    // A SINGLE stop code point makes this scan a `memchr`, and V8 implements
-    // `String.prototype.indexOf` with a SIMD one. Measured 4.3x over the char
-    // loop on a 0.97 MiB corpus, 61 of 61 interleaved rounds
-    // (scratchpad/native-primitive-bakeoff/micro-scanto.mjs, regime (a)).
-    // Semantics are identical: the loop stops at the first stop char or at
-    // `input.length`, which is exactly `indexOf`'s hit / not-found pair.
-    // Multi-member stop sets stay on the loop — 3x indexOf + min measured at
-    // parity (0.992), because the min-reduce rescans the tail and discards it.
-    const stopCp =
-      shape.stop.length === 1 && shape.stop[0]![0] === shape.stop[0]![1] ? shape.stop[0]![0] : null
+    // A char loop, not `String.prototype.indexOf`. An opt-in `indexOf` variant
+    // (`PARSEMAN_SCANTO=indexof`) won 4.3x in a microbenchmark but was never
+    // claimed as a win on real grammars (CHANGELOG), and nothing enabled it; it
+    // last existed at `4a5d0341`.
     const scanLine =
-      stopCp !== null && stopCp <= 0xffff && scanToIndexOfEnabled()
-        ? // No temp is minted: a temp would renumber every later variable in the
-          // function and show up as an artifact-size delta that is counter
-          // renumbering rather than this change (the §9.1.4 / §9.2 effect).
-          `${ind}  ${j} = input.indexOf(${JSON.stringify(String.fromCharCode(stopCp))}, ${j})` +
-          `; if (${j} < 0) ${j} = input.length`
-        : `${ind}  while (${j} < input.length && !(${classCond(`input.charCodeAt(${j})`, shape.stop)})) ${j}++`
+      `${ind}  while (${j} < input.length && !(${classCond(`input.charCodeAt(${j})`, shape.stop)})) ${j}++`
     return {
       setup: [
         `${ind}let ${j} = ${start}`,
@@ -1549,23 +1528,13 @@ export function emitShapeMatch(
     ? `${codeAt(start, firstChar)} === ${shape.open[0]}`
     : litCond(start, shape.open, firstChar)
   const closeChk = litCond(j, shape.close)
-  // Scanning to a fixed close literal IS `indexOf`, and V8's is SIMD. The
-  // rewrite is exact: the loop stops at the first close literal at or after `j`,
-  // or runs out of room and leaves the token unterminated (no match). `indexOf`
-  // returns that same first index, or -1 for "never occurs" — mapped to
-  // `input.length`, which makes the `j + closeLen <= input.length` guard fail
-  // exactly where the loop's room check did. When it IS found the close literal
-  // matches by construction, so the guard's re-comparison is dropped.
-  const closeStr = String.fromCharCode(...shape.close)
-  const scanLines = scanToIndexOfEnabled()
-    ? [
-        `${ind}  ${j} = input.indexOf(${JSON.stringify(closeStr)}, ${j}); if (${j} < 0) ${j} = input.length`,
-        `${ind}  if (${j} + ${closeLen} <= input.length) ${endV} = ${j} + ${closeLen}`,
-      ]
-    : [
-        `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,
-        `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,
-      ]
+  // The loop stops at the first close literal at or after `j`, or runs out of
+  // room and leaves the token unterminated (no match). The same `indexOf`
+  // variant as `until` above was removed with it.
+  const scanLines = [
+    `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,
+    `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`,
+  ]
   return {
     setup: [
       `${ind}let ${j} = ${start}`,

package/src/table/site-labels.ts

@@ -81,7 +81,7 @@ export const CAP_OFF = 1
 export const CAP_ON = 2
 
 /** Buffer raw-entry mode is not provable at this site. */
-export const RAW_UNKNOWN = 0
+const RAW_UNKNOWN = 0
 /** Buffer retains raw entry values. */
 export const RAW_CAPTURE = 1
 /** Buffer retains only a raw source-order count. */

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.59.0'
+export const PARSEMAN_VERSION = '0.59.2'