parseman 0.60.3 → 0.60.4

package/dist/table/index.js

@@ -5736,7 +5736,7 @@ function projectChild(children2, project, type) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.3";
+var PARSEMAN_VERSION = "0.60.4";
 
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf8, PlainNode as PlainNode2, PlainSpan as PlainSpan9 } from "../cst/plain.js";

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * 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 declare const PARSEMAN_VERSION = "0.60.3";
+export declare const PARSEMAN_VERSION = "0.60.4";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.60.3",
+  "version": "0.60.4",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/compiler/ir-serialize.ts

@@ -147,9 +147,11 @@ function matcherExpr(entry: DispatchMatcherCase): string {
 export function serializeRuleMap(
   ruleMap: ReadonlyArray<readonly [string, Comb]>,
   scanSkip?: readonly Comb[] | null,
+  /** External names the factory read through `g`; any no rule body reaches is kept as `void g[name]`. */
+  accessed?: readonly string[],
 ): string | null {
   try {
-    return new Serializer(ruleMap, scanSkip ?? []).run()
+    return new Serializer(ruleMap, scanSkip ?? [], accessed ?? []).run()
   } catch (e) {
     if (e instanceof Unserializable) {
       // `compileLinkableTable()` reaches this at run time, so it runs in browsers too.
@@ -190,9 +192,13 @@ class Serializer {
   private ruleMap: ReadonlyArray<readonly [string, Comb]>
   private scanSkip: readonly Comb[]
 
-  constructor(ruleMap: ReadonlyArray<readonly [string, Comb]>, scanSkip: readonly Comb[] = []) {
+  private accessed: readonly string[]
+  private referenced = new Set<string>()
+
+  constructor(ruleMap: ReadonlyArray<readonly [string, Comb]>, scanSkip: readonly Comb[] = [], accessed: readonly string[] = []) {
     this.ruleMap = ruleMap
     this.scanSkip = scanSkip
+    this.accessed = accessed
     for (const [name, c] of ruleMap) {
       this.localRuleNames.set(c, name)
       this.ruleValues.add(this.body(c))
@@ -294,6 +300,11 @@ class Serializer {
     const body = this.ruleMap
       .map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c), [])}`)
       .join(',\n')
+    // A name the factory read through `g` that no rule body reaches still creates
+    // its slot, so a composition that defines it nowhere refuses it.
+    for (const name of this.accessed) {
+      if (!this.referenced.has(name)) innerDecls.push(`void g[${JSON.stringify(name)}]`)
+    }
     // Shared consts go INSIDE the factory: they can reference `g[name]` rule refs,
     // and `g` only exists in the factory scope.
     const factory = innerDecls.length === 0
@@ -412,7 +423,7 @@ class Serializer {
     switch (def.tag) {
       case 'lazy': {
         const name = this.localRuleNames.get(c) ?? ruleNameOf(c)
-        if (name !== undefined) return `g[${JSON.stringify(name)}]`
+        if (name !== undefined) { this.referenced.add(name); return `g[${JSON.stringify(name)}]` }
         const target = lazyTarget(c)!
         // Innermost matching frame wins.
         for (let i = frames.length - 1; i >= 0; i--) {

package/src/compiler/linker.ts

@@ -372,24 +372,40 @@ function declaredNamesOf(items: Array<LinkableTable | Record<string, unknown>>):
   return [...names]
 }
 
+/**
+ * The reason a linked map is incomplete, or `undefined` when every `g.X` some piece
+ * reads is defined by some piece. A linked namespace holds every name a factory
+ * merely ACCESSED, so a name nobody defines is a slot that stays undefined. Runtime
+ * `compose()` and the macro's build-time fuse both refuse it with these words, naming
+ * the rule that reaches the hole when one does.
+ */
+export function danglingReference(
+  map: Record<string, Combinator<unknown>>,
+  /** Names read through `g` that `map` itself does not hold (a merge-by-name fuse drops them). */
+  accessed: Iterable<string> = [],
+): string | undefined {
+  const holes = new Set<string>()
+  for (const [name, rule] of Object.entries(map)) {
+    if (rule._def.tag !== 'lazy') continue
+    try { rule._def.thunk() } catch { holes.add(name) }
+  }
+  for (const name of accessed) if (!Object.hasOwn(map, name)) holes.add(name)
+  if (holes.size === 0) return undefined
+  const missing = [...holes]
+  for (const [name, deps] of ruleDependencies(Object.entries(map).filter(([n]) => !holes.has(n)))) {
+    for (const dep of deps) if (holes.has(dep)) return `rule "${name}" references missing rule "${dep}"`
+  }
+  return `rule(s) ${missing.map(n => `"${n}"`).join(', ')} are referenced but defined by no composed grammar`
+}
+
 /** Link recipes into one interpreter map, refusing a name nobody defines. */
 function linkComposition(
   recipes: readonly RulesRecipe[],
   link: LinkOptions,
 ): Record<string, Combinator<unknown>> {
   const map = linkRules(recipes, link)
-  const missing: string[] = []
-  for (const [name, rule] of Object.entries(map)) {
-    if (rule._def.tag !== 'lazy') continue
-    try { rule._def.thunk() } catch { missing.push(name) }
-  }
-  if (missing.length > 0) {
-    const holes = new Set(missing)
-    for (const [name, deps] of ruleDependencies(Object.entries(map).filter(([n]) => !holes.has(n)))) {
-      for (const dep of deps) if (holes.has(dep)) throw new Error(`compose: rule "${name}" references missing rule "${dep}"`)
-    }
-    throw new Error(`compose: rule(s) ${missing.map(n => `"${n}"`).join(', ')} are referenced but defined by no composed grammar`)
-  }
+  const dangling = danglingReference(map)
+  if (dangling !== undefined) throw new Error(`compose: ${dangling}`)
   // A borrowed rule object keeps its own grammar's bindings here but would be rebound
   // by name in `compile()` of this composition: refuse it rather than let the two
   // engines accept different input.

package/src/plugin/evaluator.ts

@@ -1613,9 +1613,20 @@ export function evaluateParserFactory(
    */
   const map = new Map<string, Combinator<unknown>>()
   for (const key of keys) map.set(key, built[key]!)
+  const declared = new Set(keys)
+  externalAccesses.set(map, Object.keys(built).filter(name => !declared.has(name)))
   return map
 }
 
+/**
+ * Every EXTERNAL name an evaluated factory read through `g`, keyed by the map
+ * `evaluateParserFactory` returned. The map holds declared rules only, so a `g.X`
+ * read outside every rule body (`const unused = g.X`) leaves no trace in it; the
+ * IR serializer reads this to keep that access, so a composition refuses an `X`
+ * nobody defines exactly as runtime `compose()` does.
+ */
+export const externalAccesses = new WeakMap<ReadonlyMap<string, Combinator<unknown>>, readonly string[]>()
+
 /** A combinator slot created by ref() — has a callable `define`. */
 type DefinableRef = Combinator<unknown> & { define(p: Combinator<unknown>): void }
 

package/src/plugin/index.ts

@@ -24,7 +24,7 @@ import { createUnplugin } from 'unplugin'
 import { parseSync } from 'oxc-parser'
 import { ResolverFactory } from 'oxc-resolver'
 import MagicString from 'magic-string'
-import { evaluateExpr, evaluateCombinatorArray, evaluateParserFactory, evaluateStaticValue, evaluateWordFactory, evaluateWhenFactory, evaluateRefDeclaration, applyDefineStatement, referencesAny, setReducerResolver, setBuilderImportResolver, propName, ModuleScope, type FreeNameResolution, type Scope, type ScopeEntry } from './evaluator.ts'
+import { evaluateExpr, evaluateCombinatorArray, evaluateParserFactory, externalAccesses, evaluateStaticValue, evaluateWordFactory, evaluateWhenFactory, evaluateRefDeclaration, applyDefineStatement, referencesAny, setReducerResolver, setBuilderImportResolver, propName, ModuleScope, type FreeNameResolution, type Scope, type ScopeEntry } from './evaluator.ts'
 import { classifyRuleMap } from '../analysis/commitment.ts'
 import { compile } from '../table/compile.ts'
 import { compileRuleMap, type CompiledRuleMapTable } from '../table/compile-rule-map.ts'
@@ -37,7 +37,7 @@ import {
   resolveDegradationLevel, recordDegradation, degradationCaptureDepth, unwindDegradationCapture,
 } from '../compiler/degradation.ts'
 import type { HostMode } from '../cst/host-mode.ts'
-import { COMPOSED_PIECES, type IRPiece } from '../compiler/linker.ts'
+import { COMPOSED_PIECES, danglingReference, type IRPiece } from '../compiler/linker.ts'
 import { serializeCombinator, serializeRuleMap } from '../compiler/ir-serialize.ts'
 import { evalCombinatorIR, evalRulesIR, INERT_BUILDER } from './ir-eval.ts'
 import { countSiteVisits } from '../table/assemble.ts'
@@ -220,6 +220,15 @@ const DEFAULT_ASSEMBLY_BUDGET = 0.25
  * ~79 ms against ~14 ms on `benchmark.less`. "Couldn't be inlined" alone does not
  * tell an author which construct to change; the compiler knows, so it says.
  */
+/** A build failure the lowering must not soften into a warning and a fallback. */
+class LinkRefusal extends Error {}
+
+/** Whether a rule-map entry has a definition (a `g.X` merely read does not). */
+function isResolved(rule: Combinator<unknown>): boolean {
+  if (rule._def.tag !== 'lazy') return true
+  try { rule._def.thunk(); return true } catch { return false }
+}
+
 function reasonSuffix(runtimeOnly: readonly string[] | undefined): string {
   return runtimeOnly === undefined || runtimeOnly.length === 0
     ? ''
@@ -2136,17 +2145,15 @@ function transformMacroImpl(
   const mergedCarriedRules = (
     items: CarriedItem[],
     link: LinkOptions,
-  ): { rules: Array<[string, Combinator<unknown>]>; trackLines: boolean } | null => {
+  ): { rules: Array<[string, Combinator<unknown>]>; trackLines: boolean; dangling: string | undefined } | null => {
     const carriedMaps = carriedRuleMaps(items)
     if (carriedMaps === null) return null
     const linked = linkRules(carriedMaps.pieces.flatMap(p => p.recipes), link)
     // A name some piece only REFERENCES and none defines stays an undefined slot in
-    // the namespace. It is not a rule, so it is not handed to the encoder as one.
-    const rules = Object.entries(linked).filter(([, rule]) => {
-      if (rule._def.tag !== 'lazy') return true
-      try { rule._def.thunk(); return true } catch { return false }
-    })
-    return { rules, trackLines: carriedMaps.trackLines }
+    // the namespace. Runtime `compose()` refuses that grammar at link, so the build
+    // refuses it too (the caller throws `dangling`) rather than encode around the hole.
+    const dangling = danglingReference(linked)
+    return { rules: Object.entries(linked), trackLines: carriedMaps.trackLines, dangling }
   }
 
   /**
@@ -2183,7 +2190,7 @@ function transformMacroImpl(
     // `rules({ scanSkip }, …)` options, which stamps `_meta.grammarScanSkip` when the IR
     // is re-lowered (materializePiece → compileLinkable picks it up), and survives to a
     // downstream re-compose. The full-pieces fallback bakes it via the compile option.
-    const ir = serializeRuleMap(entries as never, scanSkip)
+    const ir = serializeRuleMap(entries as never, scanSkip, rm instanceof Map ? externalAccesses.get(rm) : undefined)
     if (ir) return { carried: [{ ns, ir, ...(trackLines ? { trackLines: true as const } : {}) }] }
     // NO FULL-PIECES FALLBACK. It used to bake the grammar to lowered source when the IR
     // would not serialize; with one lowering there is nothing to bake to, and IR is not
@@ -2337,6 +2344,7 @@ function transformMacroImpl(
       trivia: composing,
       ...(cHostMode ? { hostMode: cHostMode as HostMode } : {}),
     })
+    if (merged?.dangling !== undefined) throw new Error(`${id}:${lineOf(init.start)} — compose: ${merged.dangling}`)
     if (merged !== null) {
       // Harvest the direct-builder import provenance carried on the merged graph so
       // the re-lower pass at the end of this transform re-emits those imports.
@@ -2559,6 +2567,15 @@ function transformMacroImpl(
           }
         }
         const leafMerged = mergeRuleMaps([...carriedMaps.pieces.map(p => p.rules), localEntries])
+        // The same refusal as `compose()`, over a merge by name: a name some piece only
+        // reads (an unresolved entry of a carried map, or a local factory's external
+        // access) that no piece defines.
+        const accessed = [
+          ...carriedMaps.pieces.flatMap(p => p.rules).filter(([, rule]) => !isResolved(rule)).map(([name]) => name),
+          ...(localRules instanceof Map ? externalAccesses.get(localRules) ?? [] : []),
+        ]
+        const dangling = danglingReference(Object.fromEntries(leafMerged), accessed)
+        if (dangling !== undefined) throw new LinkRefusal(`${id}:${lineOf(init.start)} — composeLeaf: ${dangling}`)
         // Composing-wins governs the leaf fuse too. The local entries are NOT freshly
         // evaluated (they come from this module's own `rules()` factory), so they are
         // excluded from the override — their declared trivia IS the composing candidate,
@@ -2595,6 +2612,7 @@ function transformMacroImpl(
       warn(init.start, 'composeLeaf(): a recognition piece has no re-lowerable IR')
       return null
     } catch (e) {
+      if (e instanceof LinkRefusal) throw e
       warn(init.start, `composeLeaf(): ${(e as Error).message}`)
       return null
     }
@@ -2796,7 +2814,7 @@ function transformMacroImpl(
             // lowering there is no such artifact, and a grammar that cannot serialize
             // simply is not carried: an absent carried list makes the downstream compose
             // say so, where a frozen one did not.
-            const ir = serializeRuleMap([...compiledRules.ruleMap] as never, compiledRules.scanSkip)
+            const ir = serializeRuleMap([...compiledRules.ruleMap] as never, compiledRules.scanSkip, externalAccesses.get(compiledRules.ruleMap))
             if (ir) carriedMetadata = [{ ns, ir, ...(compiledRules.trackLines ? { trackLines: true as const } : {}) }]
             // NOT SILENT. An export with no carried IR cannot be composed downstream at
             // all — the consumer's `compose()` will fall back to runtime and say so, but

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.60.3'
+export const PARSEMAN_VERSION = '0.60.4'