feat(selfhost): checker step-2 milestone 2d — RS0004/RS0012 via parse_effects port

Ports parse_effects into check.rss and adds two effects-clause diagnostics:
- RS0004 UNKNOWN_EFFECT: `fresh` or an unrecognized effect name.
- RS0012 REMOVED_RUNTIME_EFFECT: io/allocates/may_panic/may_fail/async/suspends.

parse_effects is per-item: a malformed item (`effects(a,,b)`, `effects(retains())`,
`effects(custom(x))`) recovers to RS0015 and is skipped, while valid items in the
same clause are still checked. effect_item_kind mirrors the exact validity rule
(bare single-token name, or retains(ident) spanning the whole segment).

Also fixes a latent bug shared by the RS0002/3/11 scanners: the signature scan
must begin at the `fn` keyword (ns-1), not the attribute-led decl start —
otherwise function_signature_end stops at the later `fn` and misses the whole
signature of `#deprecated(...) fn …`.

CHECKER_TARGET_CODES now 10 codes; checker_parity_corpus byte-exact over 619
files, 0 mismatches, 0 run-failures. RS0007 stays deferred (semantic
type_ref_is_copy sub-condition).

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

Author: olwang

crates/rsscript/src/selfhost_parity.rs

@@ -503,7 +503,7 @@ fn parser_parity_corpus() {
 // ---------------------------------------------------------------------------
 
 /// Diagnostic codes the rss checker is expected to reproduce.
-const CHECKER_TARGET_CODES: &[&str] = &["RS0002","RS0003","RS0005","RS0006","RS0010","RS0011","RS0016","RS0017"];
+const CHECKER_TARGET_CODES: &[&str] = &["RS0002","RS0003","RS0004","RS0005","RS0006","RS0010","RS0011","RS0012","RS0016","RS0017"];
 
 fn is_target_code(code: &str) -> bool {
     CHECKER_TARGET_CODES.contains(&code)

docs/ledgers/rss-selfhost-ledger.md

@@ -983,16 +983,27 @@ gap is VM value-representation / intrinsic-dispatch cost (the next big lever).
 - **Diagnostics (step 2, milestone 2c — DONE, 2026-07-02):** added **RS0010**
   (REMOVED_PROFILE_DECLARATION — any `profile:` decl) and **RS0011**
   (REMOVED_SHARE_EFFECT — a parameter written `name: share …`, no data effect,
-  type name `share`). Both purely structural. `CHECKER_TARGET_CODES` = **8 codes**;
-  `checker_parity_corpus` byte-exact **619 files, 0 mismatches, 0 run-failures**.
-  MEASURED-BUT-DEFERRED (footprint known, 19 corpus files): the effects-clause
-  family RS0004/RS0007/RS0012 needs a `parse_effects` port — malformed clauses
-  (`effects(a,,b)`, `effects(retains())`, `effects(custom(x))`) must recover to
-  RS0015, NOT the effect-name checks, and RS0007 has a semantic `type_ref_is_copy`
-  sub-condition; RS0008 (missing-effect) needs a Copy/sum-type table; RS0009
-  (invalid-pure) needs body analysis; RS0033 (int-range) needs literal-value
-  parsing; RS0028 (invalid-self) needs the protocol-method + first-param rules.
-  Next genuinely semantic tier: RS0021 exhaustiveness / RS0024 unknown-type (need a
+  type name `share`). Both purely structural.
+- **Diagnostics (step 2, milestone 2d — DONE, 2026-07-02):** ported `parse_effects`
+  and added **RS0004** (UNKNOWN_EFFECT — `fresh`/unrecognized effect name) and
+  **RS0012** (REMOVED_RUNTIME_EFFECT — io/allocates/may_panic/may_fail/async/
+  suspends). KEY: parse_effects is PER-ITEM — a malformed item (`,,` empty slot,
+  `retains()`, `custom(x)`) recovers to RS0015 and is SKIPPED, while valid items in
+  the SAME clause still get checked (`effects(no_panic,, native)` → both names
+  checked, empty slot → RS0015 only). `effect_item_kind` mirrors the exact
+  validity: bare single-token Name, or `retains(ident)` (close+1==end, start+3==
+  close, inner ident); everything else malformed. Also fixed a latent bug: the
+  signature scan must start at the `fn` keyword (`ns-1`), not the attribute-led decl
+  start — otherwise `function_signature_end` stops at the later `fn` (a top-level-
+  item boundary), which had hidden the effects clause of `#deprecated(...) fn …`
+  (and would have mis-scanned RS0002/3/11 there too). `CHECKER_TARGET_CODES` =
+  **10 codes**; `checker_parity_corpus` byte-exact **619 files, 0 mismatches, 0
+  run-failures**. STILL DEFERRED from this family: **RS0007** (retains-param) has a
+  semantic `type_ref_is_copy` sub-condition (a retained Copy param → RS0007) that
+  isn't token-decidable. Other deferred: RS0008 (missing-effect, needs Copy/sum
+  table), RS0009 (invalid-pure, needs body analysis), RS0033 (int-range, needs
+  literal-value parsing), RS0028 (invalid-self, protocol/first-param rules). Next
+  genuinely semantic tier: RS0021 exhaustiveness / RS0024 unknown-type (need a
   `Map<String,Def>` symbol-table pass).
 - **Lexer spans (step 3):** added a `len` field to the shared `Tok`
   (= consumed source span `j-i`, matching the Rust lexer's `index-start`) and made

selfhost/check.rss

@@ -204,7 +204,10 @@ fn find_param_open(toks: read List<Tok>, from: read Int, end: read Int) -> Int {
 // function.return_ty.is_none()). True iff no top-level `->` follows the param list.
 fn fn_missing_return(toks: read List<Tok>, start: read Int) -> Bool {
     let ns = fn_name_start(toks: read toks, i: read start)
-    let sigEnd = function_signature_end(toks: read toks, start: read start)
+    // Signature scan must begin at the `fn` keyword (ns - 1), not the decl start:
+    // when the decl is attribute-led (`#deprecated(...) fn …`), starting at `#`
+    // makes function_signature_end stop at the later `fn` (a top-level-item start).
+    let sigEnd = function_signature_end(toks: read toks, start: read (ns - 1))
     let open = find_param_open(toks: read toks, from: read ns, end: read sigEnd)
     if open < 0 { return false }
     let close = find_matching(toks: read toks, open: read open, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
@@ -234,7 +237,10 @@ fn seg_is_untyped(toks: read List<Tok>, segStart: read Int, segEnd: read Int) ->
 // ()[]{}<>) and tests each segment with seg_is_untyped.
 fn fn_has_untyped_param(toks: read List<Tok>, start: read Int) -> Bool {
     let ns = fn_name_start(toks: read toks, i: read start)
-    let sigEnd = function_signature_end(toks: read toks, start: read start)
+    // Signature scan must begin at the `fn` keyword (ns - 1), not the decl start:
+    // when the decl is attribute-led (`#deprecated(...) fn …`), starting at `#`
+    // makes function_signature_end stop at the later `fn` (a top-level-item start).
+    let sigEnd = function_signature_end(toks: read toks, start: read (ns - 1))
     let open = find_param_open(toks: read toks, from: read ns, end: read sigEnd)
     if open < 0 { return false }
     let close = find_matching(toks: read toks, open: read open, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
@@ -265,10 +271,110 @@ fn fn_has_untyped_param(toks: read List<Tok>, start: read Int) -> Bool {
     return untyped
 }
 
+// Valid v0.6 effect names for an `effects(...)` clause (check_function_effects).
+fn is_valid_effect_name(name: read String) -> Bool {
+    return name == "no_panic" || name == "noalloc" || name == "no_block" || name == "pure" || name == "unsafe" || name == "native" || name == "parallel"
+}
+
+// Removed runtime effects → RS0012 (removed_runtime_effect_replacement set).
+fn is_removed_runtime_effect(name: read String) -> Bool {
+    return name == "io" || name == "allocates" || name == "may_panic" || name == "may_fail" || name == "async" || name == "suspends"
+}
+
+// Index of the `(` of a top-level `effects(...)` clause in a function signature,
+// or -1. The clause sits after the param list, before the body.
+fn find_effects_open(toks: read List<Tok>, start: read Int) -> Int {
+    let ns = fn_name_start(toks: read toks, i: read start)
+    // Signature scan must begin at the `fn` keyword (ns - 1), not the decl start:
+    // when the decl is attribute-led (`#deprecated(...) fn …`), starting at `#`
+    // makes function_signature_end stop at the later `fn` (a top-level-item start).
+    let sigEnd = function_signature_end(toks: read toks, start: read (ns - 1))
+    let open = find_param_open(toks: read toks, from: read ns, end: read sigEnd)
+    if open < 0 { return -1 }
+    let pclose = find_matching(toks: read toks, open: read open, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
+    if pclose < 0 { return -1 }
+    let mut k = pclose + 1
+    let mut depth = 0
+    let mut r = -1
+    while k < sigEnd && r < 0 {
+        if at_symbol(toks: read toks, i: read k, code: read SYM_LPAREN) || at_symbol(toks: read toks, i: read k, code: read SYM_LANGLE) {
+            depth = depth + 1
+        } else if at_symbol(toks: read toks, i: read k, code: read SYM_RPAREN) || at_symbol(toks: read toks, i: read k, code: read SYM_RANGLE) {
+            if depth > 0 { depth = depth - 1 }
+        } else if depth == 0 && tk_text(toks: read toks, i: read k) == "effects" && at_symbol(toks: read toks, i: read (k + 1), code: read SYM_LPAREN) {
+            r = k + 1
+        }
+        k = k + 1
+    }
+    return r
+}
+
+// Classify one effects-clause item [segStart,segEnd) exactly like parse_effects:
+//   1 = a valid bare `Name` (single-token effect name)
+//   2 = a valid `retains(ident)` item
+//   0 = malformed (empty, non-ident, `name(args)`, bad retains) → skipped, no check
+fn effect_item_kind(toks: read List<Tok>, segStart: read Int, segEnd: read Int) -> Int {
+    if segStart >= segEnd { return 0 }
+    if is_ident_tok(toks: read toks, i: read segStart) == false { return 0 }
+    let name = tk_text(toks: read toks, i: read segStart)
+    if name == "retains" {
+        if at_symbol(toks: read toks, i: read (segStart + 1), code: read SYM_LPAREN) {
+            let close = find_matching(toks: read toks, open: read (segStart + 1), openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
+            if close >= 0 && (close + 1) == segEnd && (segStart + 3) == close && is_ident_tok(toks: read toks, i: read (segStart + 2)) {
+                return 2
+            }
+        }
+        return 0
+    }
+    if (segStart + 1) == segEnd { return 1 }
+    return 0
+}
+
+// Walk a function's `effects(...)` items (only the VALID ones — malformed items
+// recover to RS0015 and are skipped). `mode`: 0 = RS0004 (unknown effect: `fresh`
+// or an unrecognized name), 1 = RS0012 (removed runtime effect).
+fn effects_name_probe(toks: read List<Tok>, start: read Int, mode: read Int) -> Bool {
+    let effOpen = find_effects_open(toks: read toks, start: read start)
+    if effOpen < 0 { return false }
+    let effClose = find_matching(toks: read toks, open: read effOpen, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
+    if effClose < 0 { return false }
+    let mut k = effOpen + 1
+    let mut segStart = effOpen + 1
+    let mut depth = 0
+    let mut hit = false
+    while k < effClose {
+        if at_symbol(toks: read toks, i: read k, code: read SYM_LPAREN) {
+            depth = depth + 1
+        } else if at_symbol(toks: read toks, i: read k, code: read SYM_RPAREN) {
+            if depth > 0 { depth = depth - 1 }
+        } else if depth == 0 && at_symbol(toks: read toks, i: read k, code: read SYM_COMMA) {
+            if effect_name_hits(toks: read toks, segStart: read segStart, segEnd: read k, mode: read mode) { hit = true }
+            segStart = k + 1
+        }
+        k = k + 1
+    }
+    if effect_name_hits(toks: read toks, segStart: read segStart, segEnd: read effClose, mode: read mode) { hit = true }
+    return hit
+}
+
+// Does a single VALID bare-name item trigger `mode`? (retains/malformed items
+// never trigger RS0004/RS0012.)
+fn effect_name_hits(toks: read List<Tok>, segStart: read Int, segEnd: read Int, mode: read Int) -> Bool {
+    if effect_item_kind(toks: read toks, segStart: read segStart, segEnd: read segEnd) != 1 { return false }
+    let name = tk_text(toks: read toks, i: read segStart)
+    if mode == 1 { return is_removed_runtime_effect(name: read name) }
+    if name == "fresh" { return true }
+    if is_removed_runtime_effect(name: read name) { return false }
+    return is_valid_effect_name(name: read name) == false
+}
+
 // RS0011: a parameter written `name: share …` (no data effect, type name `share`).
 fn fn_has_share_param(toks: read List<Tok>, start: read Int) -> Bool {
     let ns = fn_name_start(toks: read toks, i: read start)
-    let sigEnd = function_signature_end(toks: read toks, start: read start)
+    // Signature scan must begin at the `fn` keyword (ns - 1), not the decl start:
+    // when the decl is attribute-led (`#deprecated(...) fn …`), starting at `#`
+    // makes function_signature_end stop at the later `fn` (a top-level-item start).
+    let sigEnd = function_signature_end(toks: read toks, start: read (ns - 1))
     let open = find_param_open(toks: read toks, from: read ns, end: read sigEnd)
     if open < 0 { return false }
     let close = find_matching(toks: read toks, open: read open, openSym: read SYM_LPAREN, closeSym: read SYM_RPAREN)
@@ -322,10 +428,12 @@ fn main() -> Unit {
     // RS0002 (any fn missing an explicit return type) / RS0003 (any untyped param).
     let mut missingReturn = false
     let mut untypedParam = false
-    // Signature-family diagnostics: RS0010 (removed profile), RS0011 (removed
-    // share data effect on a parameter).
+    // Signature-family diagnostics: RS0004 (unknown effect), RS0010 (removed
+    // profile), RS0011 (removed share data effect), RS0012 (removed runtime effect).
     let mut hasProfile = false
     let mut shareParam = false
+    let mut unknownEffect = false
+    let mut removedRuntime = false
     let mut i = 0
     let mut running = true
     while running {
@@ -471,6 +579,8 @@ fn main() -> Unit {
                     if fn_missing_return(toks: read toks, start: read i) { missingReturn = true }
                     if fn_has_untyped_param(toks: read toks, start: read i) { untypedParam = true }
                     if fn_has_share_param(toks: read toks, start: read i) { shareParam = true }
+                    if effects_name_probe(toks: read toks, start: read i, mode: read 0) { unknownEffect = true }
+                    if effects_name_probe(toks: read toks, start: read i, mode: read 1) { removedRuntime = true }
                     i = r
                 }
             } else {
@@ -488,6 +598,9 @@ fn main() -> Unit {
     if untypedParam {
         Log.write(message: read "RS0003")
     }
+    if unknownEffect {
+        Log.write(message: read "RS0004")
+    }
     if found {
         Log.write(message: read "RS0005")
     }
@@ -497,6 +610,9 @@ fn main() -> Unit {
     if shareParam {
         Log.write(message: read "RS0011")
     }
+    if removedRuntime {
+        Log.write(message: read "RS0012")
+    }
     if hasUnknownFeat {
         Log.write(message: read "RS0016")
     }
@@ -506,7 +622,7 @@ fn main() -> Unit {
     if headerCount >= 2 {
         Log.write(message: read "RS0006")
     }
-    let anyDiag = found || hasUnknownFeat || hasDupFeat || headerCount >= 2 || missingReturn || untypedParam || hasProfile || shareParam
+    let anyDiag = found || hasUnknownFeat || hasDupFeat || headerCount >= 2 || missingReturn || untypedParam || hasProfile || shareParam || unknownEffect || removedRuntime
     if anyDiag == false {
         Log.write(message: read "CLEAN")
     }