refactor(selfhost): use char literals, operator continuation, mut-scalar cursor, methods, positional binding

Apply confirmed language features to the self-hosted tools for readability
while preserving parity (556/556 on all three corpora, 0 mismatches) and the
SH-022 elision perf win (44.0x native, unchanged).

- SH-016 char literals replace code-point magic numbers in scan.rss
  (is_ident_start/cont, escape, scan_line_comment/char/string/multiline/interp,
  scan_number dot check, tokenize dispatch, line/col advance).
- SH-017 operator continuation wraps the 30-way is_kw and 25-way
  is_known_symbol `||` chains across lines.
- is_known_symbol now takes `c: read Char` (char-literal chain) instead of an
  Int code point.

Char extractions in the hot `read List<Char>` scanners flow only into compares
/ List.get, so the DeepCopy elision still fires. OOB-capable lookaheads keep
`code_at` (Int) as before.

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

Author: olwang

selfhost/check.rss

@@ -18,8 +18,9 @@
 // time). The unified `Tok` carries identifier TEXT so names can compare. Only the
 // checker-unique text accessor, name/field extraction, and the driver are here.
 //
-// rss constraints (SH-016/017/018): no char literals, single-line expressions,
-// cursors threaded positionally.
+// rss constraints (SH-016/017/018): char literals for code-point tests and
+// `||` chains wrapped via operator continuation (both in the shared scan.rss
+// prelude), cursors threaded positionally.
 
 fn tk_text(toks: read List<Tok>, i: read Int) -> String {
     if i < 0 { return "" }

selfhost/parser.rss

@@ -18,8 +18,9 @@
 // time). Only the parser-unique column accessor, feature-line predicates, and
 // the driver remain here.
 //
-// rss constraints honored (ledger SH-016/SH-017/SH-018): no char literals,
-// statement-level expressions on ONE line, cursors threaded positionally.
+// rss constraints honored (ledger SH-016/SH-017/SH-018): char literals for
+// code-point tests, `||` chains wrapped via operator continuation (both in the
+// shared scan.rss prelude), cursors threaded positionally.
 
 fn tk_col(toks: read List<Tok>, i: read Int) -> Int {
     if i < 0 { return 0 }

selfhost/scan.rss

@@ -15,9 +15,12 @@
 //   * `word_id`, mapping declaration keywords to small ids;
 //   * a single `tokenize` that builds the token list.
 //
-// rss constraints honored (ledger SH-016/017/018): no char literals (code points
-// via Char.to_code), statement-level expressions on ONE line, cursors threaded
-// positionally. SH-022: string building uses StringBuilder (O(n)).
+// rss constraints honored (ledger SH-016/017/018): char literals used for
+// code-point tests (SH-016), long `||` predicate chains wrap across lines via
+// operator/line continuation (SH-017), cursors threaded positionally.
+// SH-022: string building uses StringBuilder (O(n)); the hot per-char scanners
+// keep `chars: read List<Char>` DIRECT so the DeepCopy-elision holds (extracted
+// Chars flow only into `Char.*` intrinsics / compares / `List.get`).
 
 features: local
 
@@ -36,21 +39,32 @@ struct Tok {
 // (await, native) and builtin constants (true false Ok Err Some None Unit)
 // are NOT here — they lex as Ident.
 fn is_kw(word: read String) -> Bool {
-    return word == "if" || word == "else" || word == "for" || word == "in" || word == "match" || word == "loop" || word == "while" || word == "break" || word == "continue" || word == "return" || word == "features" || word == "class" || word == "struct" || word == "resource" || word == "handle" || word == "fn" || word == "let" || word == "pub" || word == "async" || word == "effects" || word == "drop" || word == "with" || word == "as" || word == "read" || word == "mut" || word == "take" || word == "fresh" || word == "manage" || word == "weak" || word == "local"
+    return word == "if" || word == "else" || word == "for" || word == "in"
+        || word == "match" || word == "loop" || word == "while" || word == "break"
+        || word == "continue" || word == "return" || word == "features" || word == "class"
+        || word == "struct" || word == "resource" || word == "handle" || word == "fn"
+        || word == "let" || word == "pub" || word == "async" || word == "effects"
+        || word == "drop" || word == "with" || word == "as" || word == "read"
+        || word == "mut" || word == "take" || word == "fresh" || word == "manage"
+        || word == "weak" || word == "local"
 }
 
 // Single-char symbols the oracle recognizes (crate::lexer push_one). Any other
 // char falls through to payload "?".
-fn is_known_symbol(code: read Int) -> Bool {
-    return code == 58 || code == 44 || code == 46 || code == 40 || code == 41 || code == 123 || code == 125 || code == 60 || code == 62 || code == 91 || code == 93 || code == 63 || code == 124 || code == 38 || code == 126 || code == 94 || code == 43 || code == 45 || code == 42 || code == 47 || code == 37 || code == 61 || code == 33 || code == 59 || code == 35
+fn is_known_symbol(c: read Char) -> Bool {
+    return c == ':' || c == ',' || c == '.' || c == '(' || c == ')'
+        || c == '{' || c == '}' || c == '<' || c == '>' || c == '['
+        || c == ']' || c == '?' || c == '|' || c == '&' || c == '~'
+        || c == '^' || c == '+' || c == '-' || c == '*' || c == '/'
+        || c == '%' || c == '=' || c == '!' || c == ';' || c == '#'
 }
 
 fn is_ident_start(c: read Char) -> Bool {
-    return Char.is_alpha(value: read c) || Char.to_code(value: read c) == 95
+    return Char.is_alpha(value: read c) || c == '_'
 }
 
 fn is_ident_cont(c: read Char) -> Bool {
-    return Char.is_alphanumeric(value: read c) || Char.to_code(value: read c) == 95
+    return Char.is_alphanumeric(value: read c) || c == '_'
 }
 
 // Code point at index i, or -1 if out of bounds.
@@ -82,14 +96,13 @@ fn escape(s: read String) -> String {
     let mut k = 0
     while k < m {
         let c = List.get(list: read cs, index: read k)
-        let code = Char.to_code(value: read c)
-        if code == 92 {
+        if c == '\\' {
             StringBuilder.push(builder: mut out, value: read "\\\\")
-        } else if code == 10 {
+        } else if c == '\n' {
             StringBuilder.push(builder: mut out, value: read "\\n")
-        } else if code == 9 {
+        } else if c == '\t' {
             StringBuilder.push(builder: mut out, value: read "\\t")
-        } else if code == 13 {
+        } else if c == '\r' {
             StringBuilder.push(builder: mut out, value: read "\\r")
         } else {
             StringBuilder.push(builder: mut out, value: read Char.to_string(value: read c))
@@ -105,9 +118,9 @@ fn scan_line_comment(chars: read List<Char>, n: read Int, i: read Int) -> Int {
     let mut scanning = true
     while scanning {
         if j < n {
-            let code = code_at(chars: read chars, n: read n, i: read j)
+            let c = List.get(list: read chars, index: read j)
             j = j + 1
-            if code == 10 {
+            if c == '\n' {
                 scanning = false
             }
         } else {
@@ -129,12 +142,12 @@ fn scan_char(chars: read List<Char>, n: read Int, i: read Int) -> Int {
         if j >= n {
             scanning = false
         } else {
-            let code = code_at(chars: read chars, n: read n, i: read j)
-            if code == 39 {
+            let c = List.get(list: read chars, index: read j)
+            if c == '\'' {
                 scanning = false
-            } else if code == 10 {
+            } else if c == '\n' {
                 scanning = false
-            } else if code == 92 {
+            } else if c == '\\' {
                 j = j + 2
             } else {
                 j = j + 1
@@ -155,10 +168,10 @@ fn scan_string(chars: read List<Char>, n: read Int, i: read Int) -> Int {
         if j >= n {
             scanning = false
         } else {
-            let code = code_at(chars: read chars, n: read n, i: read j)
-            if code == 34 {
+            let c = List.get(list: read chars, index: read j)
+            if c == '"' {
                 scanning = false
-            } else if code == 92 {
+            } else if c == '\\' {
                 j = j + 1
                 if j < n {
                     j = j + 1
@@ -181,10 +194,14 @@ fn scan_multiline(chars: read List<Char>, n: read Int, i: read Int) -> Int {
         if j >= n {
             scanning = false
         } else {
-            let c0 = code_at(chars: read chars, n: read n, i: read j)
-            let c1 = code_at(chars: read chars, n: read n, i: read (j + 1))
-            let c2 = code_at(chars: read chars, n: read n, i: read (j + 2))
-            if c0 == 34 && c1 == 34 && c2 == 34 {
+            let c0 = List.get(list: read chars, index: read j)
+            let mut triple = false
+            if c0 == '"' && j + 2 < n {
+                let cc1 = List.get(list: read chars, index: read (j + 1))
+                let cc2 = List.get(list: read chars, index: read (j + 2))
+                triple = cc1 == '"' && cc2 == '"'
+            }
+            if triple {
                 scanning = false
             } else {
                 j = j + 1
@@ -206,43 +223,43 @@ fn scan_interp(chars: read List<Char>, n: read Int, i: read Int) -> Int {
         if j >= n {
             scanning = false
         } else {
-            let code = code_at(chars: read chars, n: read n, i: read j)
-            if code == 34 && depth == 0 {
+            let c = List.get(list: read chars, index: read j)
+            if c == '"' && depth == 0 {
                 scanning = false
-            } else if code == 92 {
+            } else if c == '\\' {
                 j = j + 1
                 if j < n {
                     j = j + 1
                 }
-            } else if depth > 0 && code == 34 {
+            } else if depth > 0 && c == '"' {
                 j = j + 1
                 let mut inner = true
                 while inner {
                     if j >= n {
                         inner = false
                     } else {
-                        let sc = code_at(chars: read chars, n: read n, i: read j)
-                        if sc == 92 {
+                        let sc = List.get(list: read chars, index: read j)
+                        if sc == '\\' {
                             j = j + 1
                             if j < n {
                                 j = j + 1
                             }
                         } else {
                             j = j + 1
-                            if sc == 34 {
+                            if sc == '"' {
                                 inner = false
                             }
                         }
                     }
                 }
-            } else if code == 123 && depth == 0 && code_at(chars: read chars, n: read n, i: read (j + 1)) == 123 {
+            } else if c == '{' && depth == 0 && code_at(chars: read chars, n: read n, i: read (j + 1)) == 123 {
                 j = j + 2
-            } else if code == 125 && depth == 0 && code_at(chars: read chars, n: read n, i: read (j + 1)) == 125 {
+            } else if c == '}' && depth == 0 && code_at(chars: read chars, n: read n, i: read (j + 1)) == 125 {
                 j = j + 2
             } else {
-                if code == 123 {
+                if c == '{' {
                     depth = depth + 1
-                } else if code == 125 {
+                } else if c == '}' {
                     if depth > 0 {
                         depth = depth - 1
                     }
@@ -271,7 +288,12 @@ fn scan_number(chars: read List<Char>, n: read Int, i: read Int) -> Int {
             scanning = false
         }
     }
-    if code_at(chars: read chars, n: read n, i: read j) == 46 {
+    let mut dot = false
+    if j < n {
+        let cdot = List.get(list: read chars, index: read j)
+        dot = cdot == '.'
+    }
+    if dot {
         let after = j + 1
         if after < n {
             let cd = List.get(list: read chars, index: read after)
@@ -364,7 +386,6 @@ fn tokenize(source: read String) -> fresh List<Tok> {
         let startLine = curLine
         let startCol = curCol
         let c = List.get(list: read chars, index: read i)
-        let code = Char.to_code(value: read c)
         let c1 = code_at(chars: read chars, n: read n, i: read (i + 1))
         let c2 = code_at(chars: read chars, n: read n, i: read (i + 2))
         let mut j = i
@@ -374,10 +395,10 @@ fn tokenize(source: read String) -> fresh List<Tok> {
         if Char.is_whitespace(value: read c) {
             j = i + 1
             kind = 0
-        } else if code == 47 && c1 == 47 {
+        } else if c == '/' && c1 == 47 {
             j = scan_line_comment(chars: read chars, n: read n, i: read i)
             kind = 0
-        } else if code == 34 && c1 == 34 && c2 == 34 {
+        } else if c == '"' && c1 == 34 && c2 == 34 {
             let cend = scan_multiline(chars: read chars, n: read n, i: read i)
             text = slice(chars: read chars, from: read (i + 3), to: read cend)
             kind = 5
@@ -389,7 +410,7 @@ fn tokenize(source: read String) -> fresh List<Tok> {
             } else {
                 j = cend
             }
-        } else if code == 36 && c1 == 34 {
+        } else if c == '$' && c1 == 34 {
             let cend = scan_interp(chars: read chars, n: read n, i: read i)
             text = slice(chars: read chars, from: read (i + 2), to: read cend)
             kind = 4
@@ -398,7 +419,7 @@ fn tokenize(source: read String) -> fresh List<Tok> {
             } else {
                 j = cend
             }
-        } else if code == 34 {
+        } else if c == '"' {
             let cend = scan_string(chars: read chars, n: read n, i: read i)
             text = slice(chars: read chars, from: read (i + 1), to: read cend)
             kind = 3
@@ -407,7 +428,7 @@ fn tokenize(source: read String) -> fresh List<Tok> {
             } else {
                 j = cend
             }
-        } else if code == 39 {
+        } else if c == '\'' {
             let cend = scan_char(chars: read chars, n: read n, i: read i)
             text = slice(chars: read chars, from: read (i + 1), to: read cend)
             kind = 9
@@ -430,21 +451,21 @@ fn tokenize(source: read String) -> fresh List<Tok> {
             }
             val = word_id(word: read word)
             text = word
-        } else if code == 45 && c1 == 62 {
+        } else if c == '-' && c1 == 62 {
             j = i + 2
             kind = 7
             val = 256
             text = "->"
-        } else if code == 61 && c1 == 62 {
+        } else if c == '=' && c1 == 62 {
             j = i + 2
             kind = 7
             val = 257
             text = "=>"
         } else {
             j = i + 1
             kind = 7
-            if is_known_symbol(code: read code) {
-                val = code
+            if is_known_symbol(c: read c) {
+                val = Char.to_code(value: read c)
                 text = Char.to_string(value: read c)
             } else {
                 val = 63
@@ -459,7 +480,7 @@ fn tokenize(source: read String) -> fresh List<Tok> {
         let mut k = i
         while k < j {
             let ch = List.get(list: read chars, index: read k)
-            if Char.to_code(value: read ch) == 10 {
+            if ch == '\n' {
                 curLine = curLine + 1
                 curCol = 1
             } else {