parseman 0.56.0 → 0.58.0

package/src/table/child-slots.ts

@@ -1,5 +1,5 @@
 import {
-  OP_ADJ, OP_ARMGATE, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_DISPATCH, OP_EMPTY, OP_EXPECT,
+  OP_ADJ, OP_ARMGATE, OP_RGATE, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_DISPATCH, OP_EMPTY, OP_EXPECT,
   OP_FIELD, OP_GATE, OP_GREEDY, OP_GUARD, OP_LABEL, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_LIT_CI,
   OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_LIVE, OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT,
   OP_PEEK, OP_REJECT, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX, OP_RX_TRACK, OP_SCAN,
@@ -19,12 +19,10 @@ import {
  * only against it happening WITHIN that file.
  *
  * The subset was never load-bearing. The five opcodes it omitted — COV, GREEDY,
- * REJECT, ARMGATE, WITHCTX — are exactly the five `emit-assembly.ts` has no case
- * for, so any program containing one throws `Unemittable` from the default arm and
- * the whole assembly falls back to closures. Walking into their subtrees can
- * therefore only affect a result that is about to be discarded. (Verified: none of
- * the five is so much as imported by `emit-assembly.ts`. Its one consumer of these
- * edges, the `fd`/`er` sink census, is computed before the lowering that throws.)
+ * REJECT, ARMGATE, WITHCTX — were exactly the five `emit-assembly.ts` had no case
+ * for. ARMGATE and WITHCTX are lowered there now, so their subtrees are walked like
+ * any other; COV, GREEDY and REJECT still throw `Unemittable` from the default arm,
+ * and the whole assembly falls back to closures.
  *
  * `code` is `ArrayLike<number>` because the two callers hold different
  * representations of the same stream — `TableProgram.code` is a `readonly number[]`,
@@ -55,7 +53,7 @@ export function childSlots(code: ArrayLike<number>, ip: number, out: number[]):
 
     // Single child at `ip + 2`.
     case OP_GATE: case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM:
-    case OP_NODE: case OP_NODE_TRACK: case OP_FIELD: case OP_LEAF: case OP_SOURCE_LEAF: case OP_ARMGATE:
+    case OP_NODE: case OP_NODE_TRACK: case OP_FIELD: case OP_LEAF: case OP_SOURCE_LEAF: case OP_ARMGATE: case OP_RGATE:
       out.push(code[ip + 2]!)
       return true
 

package/src/table/compile-rule-map.ts

@@ -4,20 +4,17 @@ import type { HostMode } from '../cst/host-mode.ts'
 import { collectGrammarReflection, GRAMMAR_REFLECTION, type GrammarReflection } from '../cst/reflection.ts'
 import { encodeTableProgram, type TableSettings } from './encode.ts'
 import { defaultAssemblyCfgs, emitTableExpression } from './emit.ts'
+import { emitAssemblySource, Unemittable } from './emit-assembly.ts'
+import { selectHotSites } from './select-hot.ts'
+
+/** The most the entry supercompiler may grow an assembly (`entry-supercompiler.ts`, its 5% source cap). */
+const SUPERCOMPILE_GROWTH = 1.05
 import { tableRules } from './assemble.ts'
-import { closureArtifact } from './program.ts'
+import { assemblyExtraIps, closureArtifact, resolveTable } from './program.ts'
 import type { TableProgram, TableRule } from './program.ts'
 import { buildGrammarPlan, type GrammarCoverageDefinition } from '../compiler/grammar-coverage-ids.ts'
 import { runDuplicationDiagnosticRules, type DuplicationOption } from './duplication-hook.ts'
 
-/**
- * Static assembly has a fixed source cost that tiny grammars cannot amortize.
- * The canonical size probe's composeLeaf is 62 words and grows by ~12 kB with
- * a factory; the shipping Jess leaves are 6,365/10,892 words. Keep the policy
- * between those measured populations so small artifacts retain table density.
- */
-const DEFAULT_PRECOMPILE_MIN_WORDS = 1_024
-
 /**
  * `compileRuleMap()` FOR THE TABLE LOWERING — the counterpart that did not exist.
  *
@@ -116,8 +113,16 @@ export type CompiledRuleMapTable = {
   /** Re-emit the same table call with construction-time artifact metadata. */
   replacementWithMetadata(
     metadataSource: string,
-    options?: { readonly precompileDefault?: boolean },
+    options?: { readonly select?: ReadonlySet<number> },
   ): string
+  /**
+   * The sites a SELECTIVE default assembly emits within `budget` bytes — its
+   * fixed prelude plus the site bodies `select-hot.ts` ranks highest — and the
+   * bytes that spends. Empty for a CST or line-tracking table (only the default
+   * AST/no-lines option set is pre-compiled), for a budget smaller than the
+   * prelude, and for a table the emitter refuses, which names the construct.
+   */
+  selectAssembly(budget: number, profile?: ArrayLike<number>): { readonly sites: ReadonlySet<number>; readonly bytes: number; readonly refusal?: string }
   hostMode: HostMode
   hostBranchElided: boolean
   reflection: GrammarReflection
@@ -234,7 +239,7 @@ function withAmbient(
 export function compileRuleMapRunnable(
   ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,
   opts: TableRuleMapOptions = {},
-): Omit<CompiledRuleMapTable, 'replacement' | 'replacementWithMetadata'> | null {
+): Omit<CompiledRuleMapTable, 'replacement' | 'replacementWithMetadata' | 'selectAssembly'> | null {
   const encoded = encodeForRun(ruleMap, opts)
   if (encoded === null) return null
   const { prog, hostMode, plan } = encoded
@@ -331,23 +336,67 @@ export function compileRuleMap(
 
   const replacementWithMetadata = (
     metadataSource?: string,
-    options: { readonly precompileDefault?: boolean } = {},
+    options: { readonly select?: ReadonlySet<number> } = {},
   ): string => emitTableExpression(artifact, {
     entry: null,
     runtimeRef: opts.runtimeRef ?? 'tableRules',
     fnSources: sources as string[],
-    ...(options.precompileDefault === true && hostMode === 'ast' && prog.lines !== 1
-      && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS
-      ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) }
+    ...(options.select !== undefined && options.select.size > 0
+      ? { assemblies: [{ ...defaultAssemblyCfgs(artifact)[0]!, select: options.select }] }
       : {}),
     ...(metadataSource === undefined ? {} : { metadataSource }),
   })
   const replacement = replacementWithMetadata()
+  const selectAssembly = (budget: number, profile?: ArrayLike<number>): { sites: ReadonlySet<number>; bytes: number; refusal?: string } => {
+    const none = { sites: new Set<number>(), bytes: 0 }
+    if (hostMode !== 'ast' || prog.lines === 1) return none
+    const table = resolveTable(artifact)
+    const cfg = defaultAssemblyCfgs(artifact)[0]!
+    const roots = assemblyExtraIps(artifact)
+    let siteBytes, fixed
+    try {
+      siteBytes = emitAssemblySource(table, artifact, cfg, roots, true).siteBytes
+      // What any selective assembly costs before its first site body: the shared
+      // prelude and the factory's tail. A budget that cannot cover it buys nothing.
+      fixed = emitAssemblySource(table, artifact, cfg, roots, true, new Set()).source.length
+    } catch (e) {
+      if (e instanceof Unemittable) return { ...none, refusal: e.construct }
+      throw e
+    }
+    // The estimate (prelude plus site bodies) leaves out what selected sites add
+    // around their bodies — shared helpers and the `_px` wrappers of the closure
+    // sites they call — and the supercompiler may grow the source by up to 5%. So
+    // the selection is judged by the source it actually emits, scaled for that 5%,
+    // and narrowed until that fits.
+    const ceiling = budget / SUPERCOMPILE_GROWTH
+    // A budget that cannot cover the prelude buys nothing, by design: no refusal.
+    if (ceiling <= fixed) return none
+    // Narrowed until it fits, with no attempt limit: the target shrinks by at
+    // least 1% a round, so the selection either fits or empties. An empty one
+    // says why — a build that asked for an assembly and silently shipped none is
+    // a regression no test sees (the artifact still parses, on the closures).
+    let target = ceiling
+    for (;;) {
+      const sites = selectHotSites(artifact.code, Object.values(artifact.rules), siteBytes, target - fixed, profile)
+      if (sites.size === 0) {
+        return {
+          ...none,
+          refusal: `a site within its ${Math.floor(ceiling)} B selection ceiling (the prelude alone is ${fixed} B)`,
+        }
+      }
+      const bytes = emitAssemblySource(table, artifact, cfg, roots, true, sites).source.length
+      if (bytes <= ceiling) return { sites, bytes: Math.ceil(bytes * SUPERCOMPILE_GROWTH) }
+      // Scale by the overshoot, and by at least 1%: near the ceiling a site is
+      // the unit, and the ratio alone can stall a few bytes over it.
+      target *= Math.min(ceiling / bytes, 0.99)
+    }
+  }
 
   return {
     keys: ruleMap.map(([key]) => key),
     replacement,
     replacementWithMetadata,
+    selectAssembly,
     hostMode,
     // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
     // dropped", which is what the driver's `'ast' artifact + CST host` check keys