feat(selfhost): AST producer — param defaults, &-types, unclosed body → 592/606

- Param default values (`height: Int = 2`) now emit a `default` child (dump_param).
- Type names skip non-ident prefix tokens like a leading `&` (`&Bytes` → name=Bytes),
  matching parse_type_ref's name_index; bounded by a type terminator.
- Unclosed fn body (`fn f() { …<EOF>`) → program-level malformed-declaration via a
  proper fn_malformed predicate (no name / unclosed params / unclosed body).
- next_decl_skip now mirrors skip_unknown_top_level: an unclosed `{` on the decl
  line skips to EOF (not just the line end), so leftover tokens aren't re-parsed
  as spurious unknown-top-level items.

Corpus reach: 581 -> 592 / 606 byte-exact (+11), still 0 run-failures. Floor -> 592.
55 samples green.

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

Author: olwang

crates/rsscript/src/selfhost_parity.rs

@@ -1522,7 +1522,7 @@ const AST_SAMPLE_MIN: usize = 6;
 /// 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 = 581;
+const AST_CORPUS_PARITY_FLOOR: usize = 592;
 
 /// Step-2 measurement gate (ignored by default): how many corpus files the rss
 /// producer reproduces byte-for-byte. Not full parity yet — this ratchets a floor

selfhost/astdump.rss

@@ -969,6 +969,11 @@ fn is_type_prefix(toks: read List<Tok>, j: read Int) -> Bool {
     return is_kw_text(toks: read toks, i: read j, word: read "read") || is_kw_text(toks: read toks, i: read j, word: read "mut") || is_kw_text(toks: read toks, i: read j, word: read "take") || is_kw_text(toks: read toks, i: read j, word: read "fresh") || is_kw_text(toks: read toks, i: read j, word: read "handle") || is_kw_text(toks: read toks, i: read j, word: read "weak") || is_kw_text(toks: read toks, i: read j, word: read "noescape") || is_kw_text(toks: read toks, i: read j, word: read "owned")
 }
 
+// Tokens that end a type ref (used to bound the name search).
+fn is_type_terminator(toks: read List<Tok>, j: read Int) -> Bool {
+    return tk_kind(toks: read toks, i: read j) == TOK_EOF || at_symbol(toks: read toks, i: read j, code: read SYM_COMMA) || at_symbol(toks: read toks, i: read j, code: read SYM_RPAREN) || at_symbol(toks: read toks, i: read j, code: read SYM_RANGLE) || at_symbol(toks: read toks, i: read j, code: read SYM_RBRACE) || at_symbol(toks: read toks, i: read j, code: read SYM_LBRACE) || at_symbol(toks: read toks, i: read j, code: read SYM_SEMI) || at_symbol(toks: read toks, i: read j, code: read SYM_EQ)
+}
+
 fn emit_type_ref(toks: read List<Tok>, i: read Int, tag: read String, eff: read String, d: read Int) -> Int {
     // Prefix flags reflect ONLY the token at `i` (matching parse_type_ref, which
     // reads is_fresh/is_noescape/is_owned from tokens[start]).
@@ -978,9 +983,20 @@ fn emit_type_ref(toks: read List<Tok>, i: read Int, tag: read String, eff: read
     if at_ident(toks: read toks, i: read i, wid: read WORD_FRESH) { isFresh = true }
     else if is_kw_text(toks: read toks, i: read i, word: read "noescape") { isNoescape = true }
     else if is_kw_text(toks: read toks, i: read i, word: read "owned") { isOwned = true }
-    // Name is the first non-prefix token.
+    // Name is the first non-prefix IDENT (parse_type_ref's name_index skips both
+    // prefix keywords AND non-ident tokens like a leading `&`), bounded by a type
+    // terminator so a malformed type never scans away.
     let mut j = i
-    while is_type_prefix(toks: read toks, j: read j) { j = j + 1 }
+    let mut scanning = true
+    while scanning {
+        if is_ident_tok(toks: read toks, i: read j) && is_type_prefix(toks: read toks, j: read j) == false {
+            scanning = false
+        } else if is_type_terminator(toks: read toks, j: read j) {
+            scanning = false
+        } else {
+            j = j + 1
+        }
+    }
     let name = tk_text(toks: read toks, i: read j)
     j = j + 1
     local sb = StringBuilder.new()
@@ -1825,7 +1841,12 @@ fn emit_params(toks: read List<Tok>, open: read Int, close: read Int, d: read In
                     line = String.concat(left: read l2, right: read effStr)
                 }
                 emit(depth: read d, s: read line)
-                emit_type_ref(toks: read toks, i: read k, tag: read "type", eff: read "", d: read (d + 1))
+                let afterType = emit_type_ref(toks: read toks, i: read k, tag: read "type", eff: read "", d: read (d + 1))
+                // Default value: `name: Type = <expr>` (dump_param emits it after type).
+                if at_symbol(toks: read toks, i: read afterType, code: read SYM_EQ) {
+                    emit(depth: read (d + 1), s: read "default")
+                    emit_expr(toks: read toks, start: read (afterType + 1), end: read segEnd, d: read (d + 2))
+                }
             }
         }
         if comma < 0 { i = close } else { i = comma + 1 }
@@ -2615,8 +2636,7 @@ fn main() -> Unit {
                 // A fn whose name won't parse (`fn (…)`) is a program-level malformed
                 // declaration (parse_function_decl returns None) — counted for the
                 // section-5 marker, not emitted as a fn.
-                let ns = fn_name_start(toks: read toks, start: read i)
-                if ns >= 0 && take_function_name(toks: read toks, i: read ns) < 0 {
+                if fn_malformed(toks: read toks, start: read i) {
                     malDecl = malDecl + 1
                     i = advance(toks: read toks, i: read i, r: read next_decl_skip(toks: read toks, start: read i))
                 } else {
@@ -2659,6 +2679,29 @@ fn fn_name_start(toks: read List<Tok>, start: read Int) -> Int {
     return j + 1
 }
 
+// True if a fn head at `start` fails to parse (parse_function_decl returns None):
+// no name, unclosed params `(`, or a body `{` with no matching `}`.
+fn fn_malformed(toks: read List<Tok>, start: read Int) -> Bool {
+    let ns = fn_name_start(toks: read toks, start: read start)
+    if ns < 0 { return false }
+    let nameEnd = take_function_name(toks: read toks, i: read ns)
+    if nameEnd < 0 { return true }
+    let popen = parse_generic_params(toks: read toks, i: read nameEnd)
+    let mut sigStart = popen
+    if at_symbol(toks: read toks, i: read popen, code: read SYM_LPAREN) {
+        let pclose = find_matching(toks: read toks, open: read popen, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
+        if pclose < 0 { return true }
+        sigStart = pclose + 1
+    }
+    let sigEnd = function_signature_end(toks: read toks, start: read sigStart)
+    if at_symbol(toks: read toks, i: read sigEnd, code: read SYM_LBRACE) {
+        if find_matching(toks: read toks, open: read sigEnd, openSym: read SYM_LBRACE, closeSym: read SYM_RBRACE) < 0 {
+            return true
+        }
+    }
+    return false
+}
+
 // True if token i begins a top-level `features:` header (depth checked by caller).
 fn is_features_header(toks: read List<Tok>, i: read Int) -> Bool {
     return is_kw_text(toks: read toks, i: read i, word: read "features") && at_symbol(toks: read toks, i: read (i + 1), code: read SYM_COLON)
@@ -2760,12 +2803,18 @@ fn is_feature_word(toks: read List<Tok>, i: read Int) -> Bool {
 }
 
 // Skip an unsupported top-level item: to its block end if it has one, else its line end.
+// Skip an unknown/malformed top-level declaration (mirrors skip_unknown_top_level):
+// if the declaration line opens a `{`, skip to its matching `}` (or to EOF when it
+// never closes); otherwise skip to the declaration line end.
 fn next_decl_skip(toks: read List<Tok>, start: read Int) -> Int {
     let n = List.len(list: read toks)
-    let openb = find_block_open(toks: read toks, start: read start, limit: read n)
-    if openb >= 0 && tk_line(toks: read toks, i: read openb) == tk_line(toks: read toks, i: read start) {
+    let lineEnd = declaration_line_end(toks: read toks, start: read start)
+    let openb = find_block_open(toks: read toks, start: read start, limit: read lineEnd)
+    let mut r = lineEnd
+    if openb >= 0 {
         let close = find_matching(toks: read toks, open: read openb, openSym: read SYM_LBRACE, closeSym: read SYM_RBRACE)
-        if close > openb { return close + 1 }
+        if close < 0 { r = n } else { r = close + 1 }
     }
-    return declaration_line_end(toks: read toks, start: read start)
+    if r > start { return r }
+    return start + 1
 }

selfhost/samples/ast/x_default_args.rss

@@ -0,0 +1,13 @@
+// Default parameter values: a call may omit a trailing parameter that declares a
+// default (`name: Type = <expr>`); the default is filled in at lowering so every
+// backend sees a complete call.
+fn box_volume(width: Int, height: Int = 2, depth: Int = 3) -> Int {
+    return width * height * depth
+}
+
+fn main() -> Unit {
+    Log.write(message: read String.from_int(value: box_volume(width: 5)))
+    Log.write(message: read String.from_int(value: box_volume(width: 5, height: 4)))
+    Log.write(message: read String.from_int(value: box_volume(width: 5, height: 4, depth: 6)))
+    return Unit
+}

selfhost/samples/ast/x_ref_param.rss

@@ -0,0 +1,5 @@
+// expect: RS1004
+
+fn hash(data: &Bytes) -> UInt64 {
+    return Bytes.hash(data: read data)
+}

selfhost/samples/ast/x_unclosed_body.rss

@@ -0,0 +1,3 @@
+// expect: RS0015
+fn main() -> Unit {
+    let x = 1