feat(selfhost): AST producer declaration items — struct/sum/const/alias/module/use → 121/563

Extends astdump.rss from a function-only core to full declaration-level coverage:
- struct/class/resource: opaque, generic params + bounds (managed/struct/resource/
  protocol), derives(...), handle/weak fields, field defaults, drop bodies.
- sum: variants with fields.
- const, type-alias (with generics), module, use (glob + `as` alias).
- functions now emit generic params too.

Driver dispatch mirrors the reference parse_program order. protocols/impls/
native-modules are skipped (they dump in a separate program section, not source
order, so streaming can't place them — SH-025).

Corpus reach: 58 -> 121 / 563 byte-exact, still 0 run-failures. Floor ratcheted to
121. Six curated samples/ast/* (functions, control, logic, structs, sums, decls)
byte-exact and gating non-ignored. All 9 non-ignored selfhost tests green.

Risks closed: curated fast gate (ast_parity_samples) mitigates corpus-gate runtime;
the module story is decided (commit to concatenation) in selfhost/AST_FORMAT.md.
Residual grammar tracked as SH-025 in the ledger; plan + format docs updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/selfhost_parity.rs

@@ -1510,7 +1510,7 @@ fn ast_parity_samples() {
 /// Floor for `ast_parity_corpus` — the number of corpus files whose rss AST dump
 /// already matches the oracle byte-for-byte. Ratchets up as the producer's
 /// coverage grows; a drop signals a regression. (Full parity = files.len().)
-const AST_CORPUS_PARITY_FLOOR: usize = 58;
+const AST_CORPUS_PARITY_FLOOR: usize = 121;
 
 /// Step-2 measurement gate (ignored by default): how many of the 556 corpus files
 /// the rss producer already reproduces byte-for-byte. Not full parity yet — this

docs/ledgers/rss-selfhost-ledger.md

@@ -867,3 +867,35 @@ gap is VM value-representation / intrinsic-dispatch cost (the next big lever).
 - **Status:** fixed (feature): positional multi-field variant binding supported
   across all backends; RS0037 removed as a restriction and repurposed for arity;
   spec §20.1 amended.
+
+### SH-025 — AST-dump parity: streaming rss producer at 121/563, residual grammar is the growing tail
+
+- **Context:** step 2 of frontend object parity (after the AST-dump format +
+  oracle keystone, SH-adjacent). `selfhost/astdump.rss` is a recursive-descent
+  rss parser that STREAMS the canonical dump (`selfhost/AST_FORMAT.md`); the
+  harness (`crate::selfhost_parity`) diffs it byte-for-byte against the Rust
+  oracle over `parse_source_raw`.
+- **Reach:** 121 / 563 corpus files byte-exact, **0 run-failures** — the producer
+  never crashes; unsupported constructs mismatch (partial/`unknown-*` markers)
+  rather than panic. Curated `samples/ast/*.rss` (6 files: functions, effects,
+  control flow, calls, structs+generics+derives+handle fields, sums, module/use/
+  const/type-alias) are byte-exact and gate non-ignored; `ast_parity_corpus`
+  (`#[ignore]`) ratchets the floor (currently 121).
+- **Covered:** top-level fns (pub/async/native, generic params + bounds, params
+  with read/mut/take effects, generic-arg types, return type, body); struct/class/
+  resource (opaque, generics, derives, handle/weak fields, defaults, drop); sum
+  (variants + fields); const/type-alias/module/use; statements return/let/local/
+  assign/if-else/while-loop/break/continue/expr; a split-at-last-top-level-operator
+  expression parser matching the oracle's precedence, plus call (name/qualified/
+  receiver, named + effect args), field/index, array, try `?`, parens, literals.
+- **Residual (the tail):** for-loops, match statements/expressions, closures,
+  object/map literals, interpolated strings, `!`/`~` unary desugars, negative
+  number literals, effect-receiver calls (`read x.m()`), fn attributes
+  (`#deprecated`/`#lower_name`), effect/retains clauses, protocols/impls/
+  native-modules (they dump in a separate program section, not source order, so
+  streaming can't place them), and `statement_end` operator/postfix line
+  continuation. Each is additive; the floor ratchets as they land.
+- **Status:** open (growing tail). The producer + parity gate + risk mitigations
+  (curated fast gate; module-story decision recorded in AST_FORMAT.md) are in
+  place; full 556-file byte parity is incremental, tracked by the ratcheting
+  floor.

docs/self-hosting-stress-test-plan.md

@@ -275,3 +275,19 @@ first. Two risks to treat as their own line items when `parser.rss` starts emitt
 AST: the `scan.rss`-prepend hack (no module/import story) becomes a scaling pain once
 an AST type module is added; and corpus-gate runtime (AST dumps ≫ token dumps) will
 likely want a sampled fast inner-loop gate plus the full corpus pre-push.
+
+**Step-2 producer shipped (in progress, ratcheting).** `selfhost/astdump.rss` is a
+recursive-descent rss parser that STREAMS the canonical dump (no handle-based AST is
+materialized). Parity harness: `ast_parity_tiny_sample` + `ast_parity_samples`
+(non-ignored, byte-exact vs the oracle over curated `samples/ast/*`) and
+`ast_parity_corpus` (`#[ignore]`, ratchets a floor over all 563 files). Current
+reach: **121/563 byte-exact, 0 run-failures** (the producer never crashes;
+unsupported constructs mismatch rather than panic). Covered: fns (generics/effects/
+return/body), struct/class/resource (opaque/generics/derives/handle-weak/defaults/
+drop), sum, const/type-alias/module/use, the core statements, and a precedence-exact
+expression parser (calls, field/index, array, try, effects, literals). Both risks are
+handled: the curated set is the fast inner-loop gate; the module story is decided in
+`selfhost/AST_FORMAT.md` (commit to concatenation). The residual grammar (for/match/
+closures/object-map/interp/unary-desugars/effect-receiver/attributes/protocols/
+line-continuation) is the additive tail, tracked as **SH-025** and gated by the
+ratcheting floor.

selfhost/AST_FORMAT.md

@@ -152,6 +152,23 @@ Binary op names: `add subtract multiply divide modulo bit-and bit-or bit-xor
 shift-left shift-right equal not-equal less less-equal greater greater-equal
 logical-and logical-or`.
 
+## Producer & the module-story decision
+
+The rss producer is `selfhost/astdump.rss`, a recursive-descent parser that
+**streams** this dump (the dump is a pre-order traversal, so no handle-based AST is
+materialized — each parse fn emits its node line(s) at a threaded depth and returns
+the next token index). It reuses the shared `scan.rss` tokenizer/accessors, which
+the harness prepends at compile time.
+
+**Decision (module story):** the single-file VM model still has no cross-file
+import, so — like the lexer/parser/checker — `astdump.rss` is authored as one file
+and concatenated after `scan.rss` by the harness. We commit to concatenation for
+now rather than blocking AST parity on a new language module feature; if the
+producer grows unwieldy, the mitigation is to split the *Rust-side* corpus gate
+into sampled + full tiers (already done: curated `samples/ast/*` is the fast
+non-ignored gate, the full corpus is `#[ignore]`), not to invent an import system.
+Revisit only if a genuine multi-file need appears.
+
 ## Oracle
 
 `crate::syntax::parse_source_raw` (never the desugared `parse_source`) is truth.