feat(selfhost): checker step-2 milestones 2e/2f — RS0028, RS0033

- RS0028 INVALID_SELF_PARAMETER: a `self` param that isn't the first parameter of
  a qualified (dotted-name) method.
- RS0033 INTEGER_LITERAL_OUT_OF_RANGE: a whole-file scan for a decimal-integer
  literal token overflowing i64 (all-digit text, leading zeros stripped, 19-digit
  boundary compared digit-by-digit against i64::MAX; float/hex excluded).

CHECKER_TARGET_CODES now 12 codes (RS0002/3/4/5/6/10/11/12/16/17/28/33);
checker_parity_corpus byte-exact over 619 files, 0 mismatches, 0 run-failures.

Remaining diagnostics need semantic infrastructure (RS0007/8/9 type-Copy/body
analysis; RS0021/24 a symbol-table pass) — documented in the ledger.

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","RS0004","RS0005","RS0006","RS0010","RS0011","RS0012","RS0016","RS0017","RS0028"];
+const CHECKER_TARGET_CODES: &[&str] = &["RS0002","RS0003","RS0004","RS0005","RS0006","RS0010","RS0011","RS0012","RS0016","RS0017","RS0028","RS0033"];
 
 fn is_target_code(code: &str) -> bool {
     CHECKER_TARGET_CODES.contains(&code)

docs/ledgers/rss-selfhost-ledger.md

@@ -998,13 +998,24 @@ gap is VM value-representation / intrinsic-dispatch cost (the next big lever).
   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).
+  run-failures**.
+- **Diagnostics (step 2, milestones 2e/2f — DONE, 2026-07-02):** added **RS0028**
+  (INVALID_SELF_PARAMETER — a `self` param that isn't the first parameter of a
+  qualified/dotted-name method; mirrors check_params) and **RS0033**
+  (INTEGER_LITERAL_OUT_OF_RANGE — a whole-file scan for a decimal-integer literal
+  token whose value overflows i64, mirroring check_integer_literal_range: all-digit
+  text, leading zeros stripped, 19-digit boundary compared against i64::MAX digit-
+  by-digit; float/hex literals excluded since their text isn't all digits).
+  `CHECKER_TARGET_CODES` = **12 codes** (RS0002/3/4/5/6/10/11/12/16/17/28/33);
+  `checker_parity_corpus` byte-exact **619 files, 0 mismatches, 0 run-failures**.
+- **STILL DEFERRED (need semantic infrastructure):** **RS0007** (retains-param) has
+  a semantic `type_ref_is_copy` sub-condition (retained Copy param → RS0007) not
+  token-decidable; **RS0008** (missing-effect) needs a Copy/sum-type table +
+  noescape/owned/surface-ref classification; **RS0009** (invalid-pure, 7 files)
+  needs body analysis (manage/native-call/with-resource) + type analysis. Next
+  genuinely semantic tier: **RS0021** exhaustiveness / **RS0024** unknown-type (need
+  a `Map<String,Def>` symbol-table pass — the first self-hosted check that isn't
+  decidable from local token structure).
 - **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
   `lexer.rss` emit the real `<line>:<col>:<len>` prefix. `lexer_parity_corpus` is

selfhost/check.rss

@@ -405,6 +405,62 @@ fn fn_has_share_param(toks: read List<Tok>, start: read Int) -> Bool {
     return hit
 }
 
+// RS0033: a decimal integer literal that does not fit i64 (check_integer_literal_
+// range: all-ASCII-digit text whose value overflows). Non-decimal / float literals
+// (containing `.`, `e`, `x`, …) are left alone — their text isn't all digits.
+fn is_int_out_of_range(text: read String) -> Bool {
+    let cs = String.chars(value: read text)
+    let n = List.len(list: read cs)
+    if n == 0 { return false }
+    let mut allDigit = true
+    let mut i = 0
+    while i < n {
+        let code = Char.to_code(value: read List.get(list: read cs, index: read i))
+        if code < 48 || code > 57 { allDigit = false }
+        i = i + 1
+    }
+    if allDigit == false { return false }
+    // Strip leading zeros (Rust's i64 parse accepts them: `007` → 7).
+    let mut start = 0
+    while start < (n - 1) && Char.to_code(value: read List.get(list: read cs, index: read start)) == 48 {
+        start = start + 1
+    }
+    let digits = n - start
+    if digits > 19 { return true }
+    if digits < 19 { return false }
+    // Exactly 19 significant digits: compare against i64::MAX digit-by-digit.
+    let ms = String.chars(value: read "9223372036854775807")
+    let mut j = 0
+    let mut result = false
+    let mut decided = false
+    while j < 19 && decided == false {
+        let a = Char.to_code(value: read List.get(list: read cs, index: read (start + j)))
+        let b = Char.to_code(value: read List.get(list: read ms, index: read j))
+        if a > b {
+            result = true
+            decided = true
+        } else if a < b {
+            decided = true
+        }
+        j = j + 1
+    }
+    return result
+}
+
+// Whole-file scan: any decimal integer literal token out of i64 range → RS0033.
+fn has_out_of_range_int(toks: read List<Tok>) -> Bool {
+    let n = List.len(list: read toks)
+    let mut i = 0
+    let mut hit = false
+    while i < n {
+        if tk_kind(toks: read toks, i: read i) == TOK_NUMBER {
+            if is_int_out_of_range(text: read tk_text(toks: read toks, i: read i)) { hit = true }
+        }
+        i = i + 1
+    }
+    return hit
+}
+
 // RS0028: a parameter named `self` that is not the first parameter of a qualified
 // method (check_params: `self` && (!is_qualified_method || index != 0)). A method
 // is qualified iff its name is dotted (`Type.method`).
@@ -485,6 +541,8 @@ fn main() -> Unit {
     let mut unknownEffect = false
     let mut removedRuntime = false
     let mut invalidSelf = false
+    // RS0033: any decimal integer literal in the file that overflows i64.
+    let outOfRangeInt = has_out_of_range_int(toks: read toks)
     let mut i = 0
     let mut running = true
     while running {
@@ -668,6 +726,9 @@ fn main() -> Unit {
     if invalidSelf {
         Log.write(message: read "RS0028")
     }
+    if outOfRangeInt {
+        Log.write(message: read "RS0033")
+    }
     if hasUnknownFeat {
         Log.write(message: read "RS0016")
     }
@@ -677,7 +738,7 @@ fn main() -> Unit {
     if headerCount >= 2 {
         Log.write(message: read "RS0006")
     }
-    let anyDiag = found || hasUnknownFeat || hasDupFeat || headerCount >= 2 || missingReturn || untypedParam || hasProfile || shareParam || unknownEffect || removedRuntime || invalidSelf
+    let anyDiag = found || hasUnknownFeat || hasDupFeat || headerCount >= 2 || missingReturn || untypedParam || hasProfile || shareParam || unknownEffect || removedRuntime || invalidSelf || outOfRangeInt
     if anyDiag == false {
         Log.write(message: read "CLEAN")
     }