feat(selfhost): AST producer reaches 619/619 byte-exact — full corpus parity

Closes the final long-tail mismatches; the self-hosted streaming AST dump now
matches the Rust oracle byte-for-byte across the entire corpus (0 run-failures):

- scoped-view desugar: `view v = expr` + rest-of-block → `with v { … }` handled
  in the block statement loop (collect_statements), capturing trailing stmts.
- match arms: skip `,`/`;` separators so a trailing comma after an arm's `{ }`
  block isn't miscounted as a malformed (no-`=>`) arm.
- effect-annotated closure `read || { … }`: special-cased BEFORE the binary
  split (mirrors parse_expr) so the `||` isn't torn apart as logical-or; the
  general `read <expr>` effect stays AFTER the split (effect binds tighter than
  any operator — `read r * read r` = `(read r) * (read r)`).

Floor 609 -> 619. Corpus samples added for the fixed constructs so they stay
guarded by the fast ast_parity_samples gate.

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 = 609;
+const AST_CORPUS_PARITY_FLOOR: usize = 619;
 
 /// 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

@@ -277,6 +277,17 @@ fn emit_expr(toks: read List<Tok>, start: read Int, end: read Int, d: read Int)
         emit_explicit_fn(toks: read toks, start: read s, end: read e, d: read d)
         return Unit
     }
+    // Effect-annotated closure `read || { … }` / `mut |x| …`: handled BEFORE the
+    // binary split so the closure `|` pipes aren't read as logical-or / bit-or.
+    // (parse_expr special-cases ONLY effect+closure here; a general `read <expr>`
+    // like `read r * read r` still splits at the operator first — effect binds
+    // tighter than any binary op.)
+    let effClosure = effect_kw(toks: read toks, i: read s)
+    if String.len(value: read effClosure) > 0 && at_symbol(toks: read toks, i: read (s + 1), code: read SYM_PIPE) {
+        emit(depth: read d, s: read String.concat(left: read "effect kind=", right: read effClosure))
+        emit_closure(toks: read toks, start: read (s + 1), end: read e, d: read (d + 1))
+        return Unit
+    }
     // Binary split (lowest precedence, last top-level occurrence).
     let opIdx = find_binop(toks: read toks, start: read s, end: read e)
     if opIdx >= 0 {
@@ -315,10 +326,10 @@ fn emit_expr(toks: read List<Tok>, start: read Int, end: read Int, d: read Int)
             return Unit
         }
     }
-    // Effect prefix: read/mut/take <value>. The receiver-call shorthand
-    // `<effect> recv.method(args)` (lowercase receiver) parses as a ReceiverCall,
-    // NOT an Effect wrapper; an uppercase namespace (`read Cache.put()`) stays a
-    // qualified call under the effect.
+    // General effect prefix: read/mut/take <value>, handled AFTER the binary split
+    // (effect binds tighter than any operator). The receiver-call shorthand
+    // `<effect> recv.method(args)` (lowercase receiver) parses as a ReceiverCall;
+    // an uppercase namespace (`read Cache.put()`) stays a qualified call under it.
     let effWord = effect_kw(toks: read toks, i: read s)
     if String.len(value: read effWord) > 0 {
         let recvStart = s + 1
@@ -1694,13 +1705,39 @@ fn find_block_open(toks: read List<Tok>, start: read Int, limit: read Int) -> In
 // Emit a `block` node and its statements for the braces [open, close].
 fn emit_block(toks: read List<Tok>, open: read Int, close: read Int, d: read Int) -> Unit {
     emit(depth: read d, s: read "block")
-    let mut i = open + 1
+    emit_stmts(toks: read toks, from: read (open + 1), close: read close, d: read (d + 1))
+    return Unit
+}
+
+// True if a scoped-view binding `view <ident> = …` begins at i (is_view_binding).
+fn is_view_binding(toks: read List<Tok>, i: read Int, close: read Int) -> Bool {
+    return is_kw_text(toks: read toks, i: read i, word: read "view") && is_ident_tok(toks: read toks, i: read (i + 1)) && at_symbol(toks: read toks, i: read (i + 2), code: read SYM_EQ) && (i + 2) < close
+}
+
+// Emit statements in [from, close) at depth d. A `view name = expr` desugars to a
+// `with expr as name { <rest of block> }` that captures the remaining statements
+// (collect_statements' scoped-view desugar).
+fn emit_stmts(toks: read List<Tok>, from: read Int, close: read Int, d: read Int) -> Unit {
+    let mut i = from
     while i < close {
-        // Skip stray semicolons/commas that are statement trivia.
         if at_symbol(toks: read toks, i: read i, code: read SYM_SEMI) {
             i = i + 1
+        } else if is_view_binding(toks: read toks, i: read i, close: read close) {
+            let name = tk_text(toks: read toks, i: read (i + 1))
+            let stEnd = stmt_end(toks: read toks, start: read i, limit: read close)
+            let eqPos = first_eq(toks: read toks, start: read (i + 2), end: read stEnd)
+            emit(depth: read d, s: read String.concat(left: read "with binding=", right: read name))
+            emit(depth: read (d + 1), s: read "resource")
+            if eqPos >= 0 {
+                emit_expr(toks: read toks, start: read (eqPos + 1), end: read stEnd, d: read (d + 2))
+            } else {
+                emit(depth: read (d + 2), s: read "unknown-expr")
+            }
+            emit(depth: read (d + 1), s: read "block")
+            emit_stmts(toks: read toks, from: read stEnd, close: read close, d: read (d + 2))
+            i = close
         } else {
-            let next = emit_stmt(toks: read toks, start: read i, limit: read close, d: read (d + 1))
+            let next = emit_stmt(toks: read toks, start: read i, limit: read close, d: read d)
             if next > i { i = next } else { i = i + 1 }
         }
     }
@@ -2495,7 +2532,9 @@ fn emit_match_arms(toks: read List<Tok>, start: read Int, end: read Int, d: read
     let mut i = start
     let mut mal = 0
     while i < end {
-        if at_symbol(toks: read toks, i: read i, code: read SYM_SEMI) {
+        // Skip separators between arms (`,`/`;`) so a trailing comma after an arm's
+        // `{ }` block isn't misread as an arm with no `=>`.
+        if at_symbol(toks: read toks, i: read i, code: read SYM_SEMI) || at_symbol(toks: read toks, i: read i, code: read SYM_COMMA) {
             i = i + 1
         } else {
             let lineEnd = next_line_or_block_end(toks: read toks, start: read i, end: read end)

selfhost/samples/ast/x_await_try.rss

@@ -0,0 +1,37 @@
+features: async
+
+async fn nested_if() -> Result<Unit, TimerError> {
+    if true {
+        await Timer.sleep(ms: 1)?
+    }
+    return Ok(Unit)
+}
+
+async fn nested_loop() -> Result<Unit, TimerError> {
+    let mut count = 0
+    while count < 1 {
+        await Timer.sleep(ms: 1)?
+        count = count + 1
+    }
+    return Ok(Unit)
+}
+
+async fn nested_match(value: read Option<Int>) -> Result<Unit, TimerError> {
+    match value {
+        Some(_) => {
+            await Timer.sleep(ms: 1)?
+        },
+        None => {
+            await Timer.sleep(ms: 1)?
+        },
+    }
+    return Ok(Unit)
+}
+
+async fn main() -> Result<Unit, TimerError> {
+    await nested_if()?
+    await nested_loop()?
+    await nested_match(value: read Some(1))?
+    await nested_match(value: read None)?
+    return Ok(Unit)
+}

selfhost/samples/ast/x_closure_effect1.rss

@@ -0,0 +1,13 @@
+struct Image
+struct Callback
+
+fn store(callback: read Callback) -> Unit
+    effects(retains(callback))
+
+fn schedule_image(image: read Image) -> Unit {
+    store(callback: read || {
+        Image.inspect(image: read image)
+    })
+
+    return Unit
+}

selfhost/samples/ast/x_closure_effect2.rss

@@ -0,0 +1,25 @@
+// expect: RS0801
+features: local
+
+class Scheduler {
+    callbacks: List<Callback>
+}
+
+struct Image {
+    pixels: Buffer
+}
+
+fn schedule(scheduler: mut Scheduler, callback: read Callback) -> Unit
+    effects(retains(callback))
+{
+}
+
+fn bad_schedule(scheduler: mut Scheduler, path: read Path) -> Unit {
+    local image = Image.load(path: read path)
+    schedule(
+        scheduler: mut scheduler,
+        callback: read || {
+            Image.inspect(image: read image)
+        },
+    )
+}

selfhost/samples/ast/x_native_bool.rss

@@ -0,0 +1,43 @@
+// JIT hot path: native parent calls a compiled child with a Bool parameter and
+// Bool return, then consumes that result in native control flow. This pins the
+// staged native-call ABI for Bool values instead of relying on the Int encoding
+// accidentally working.
+
+fn bench_size(default: Int) -> Int {
+    let raw = Args.get_or_default(index: 0, default: read String.from_int(value: default))
+    match String.parse_int(value: read raw) {
+        Some(value) => {
+            return value
+        }
+        None => {
+            return default
+        }
+    }
+}
+
+fn matches(flag: Bool, value: Int) -> Bool {
+    let over = value > 10
+    return flag == over
+}
+
+fn hot(limit: Int) -> Int {
+    let mut i = 0
+    let mut total = 0
+    while i < limit {
+        let ok = matches(flag: read true, value: read i % 23)
+        if ok {
+            total = total + i
+        } else {
+            total = total - 1
+        }
+        i = i + 1
+    }
+    return total
+}
+
+fn main() -> Unit {
+    let limit = bench_size(default: 750000)
+    let result = hot(limit: limit)
+    Log.write(message: read String.from_int(value: result))
+    return Unit
+}

selfhost/samples/ast/x_pos_variant.rss

@@ -0,0 +1,42 @@
+sum Shape {
+    Circle(radius: Int)
+    Rectangle(width: Int, height: Int)
+    Prism(width: Int, height: Int, depth: Int)
+}
+
+// Two-field positional binding.
+fn area(shape: read Shape) -> Int {
+    match read shape {
+        Circle(r) => { return read r * read r * 3 }
+        Rectangle(w, h) => { return read w * read h }
+        Prism(w, h, d) => { return read w * read h * read d }
+    }
+}
+
+// Three-field positional binding with an ignored middle position.
+fn width_times_depth(shape: read Shape) -> Int {
+    match read shape {
+        Circle(r) => { return read r }
+        Rectangle(w, _) => { return read w }
+        Prism(w, _, d) => { return read w * read d }
+    }
+}
+
+// Named field patterns produce the identical result as positional binding.
+fn area_named(shape: read Shape) -> Int {
+    match read shape {
+        Circle { radius } => { return read radius * read radius * 3 }
+        Rectangle { width, height } => { return read width * read height }
+        Prism { width, height, depth } => { return read width * read height * read depth }
+    }
+}
+
+fn main() -> Unit {
+    let r = Rectangle(width: 3, height: 4)
+    let a = area(shape: read r)
+    let b = area_named(shape: read r)
+    let p = Prism(width: 2, height: 3, depth: 5)
+    let c = area(shape: read p)
+    let d = width_times_depth(shape: read p)
+    return Unit
+}

selfhost/samples/ast/x_view.rss

@@ -0,0 +1,14 @@
+// expect: RS0702
+// A scoped-view binding (`view name = expr`, spec §20.2-1) desugars to a
+// `with`-lease whose scope ends at the enclosing block, so it cannot escape via
+// return — same rule as any `with` resource.
+features: local
+
+fn bad(data: read Bytes) -> BytesView {
+    view v = Bytes.view(value: read data, start: 0, len: 1)
+    return v
+}
+
+fn main() -> Unit {
+    return Unit
+}