feat(lang): character-literal values (SH-016) + spec

Make '\''x'\'' a real Char value end to end. The lexer emits TokenKind::Char
(raw inner text), the parser produces Expr::CharLiteral / MatchLiteral::Char,
HIR gains HirExpr::Char typed Char, the reg-VM lowers a new RegInstr::LoadChar
(VmValue::Char), and the AOT backend emits a Rust char literal via
format!("{:?}", decode_char_token(..)) with no .to_string() (char is Copy).
Native keeps LoadChar as native_subset:false, so char-using functions stay on
the interpreter tier (safe parity fallback). Char is now an allowed match
scrutinee type (infinite domain, requires _).

Removes the SH-016 diagnostic scaffolding (Program.char_literal_spans, the
analyzer HashSet, the RS0015 char-literal emission). Mirrors the new
tokenization in selfhost/scan.rss (Char token kind 9, \-escape honored) so
lexer parity holds. Adds decode_char_token, a pass fixture, a differential exec
corpus pair, and a vm-eval parity test covering all escapes.

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

Author: olwang

crates/rsscript/src/analyzer.rs

@@ -208,7 +208,6 @@ fn analyze_program(
         type_alias_params,
         in_task_group: false,
         async_let_names: Vec::new(),
-        char_literal_spans: HashSet::new(),
     };
     analyzer.run();
     let mut diagnostics = analyzer.diagnostics;
@@ -275,7 +274,6 @@ fn analyze_syntax_program(
         type_alias_params: Default::default(),
         in_task_group: false,
         async_let_names: Vec::new(),
-        char_literal_spans: HashSet::new(),
     };
     analyzer.run_syntax_only();
     let mut diagnostics = analyzer.diagnostics;
@@ -311,11 +309,6 @@ pub(crate) struct Analyzer<'a> {
     pub(crate) type_alias_params: std::collections::BTreeMap<String, Vec<String>>,
     in_task_group: bool,
     pub(crate) async_let_names: Vec<String>,
-    /// Spans of folded `'...'` character-literal tokens. These get one targeted
-    /// "no character-literal syntax" diagnostic; the generic `Expr::Unknown`
-    /// walk skips them so the lone `'` operand does not also emit a duplicate
-    /// RS0015.
-    pub(crate) char_literal_spans: HashSet<crate::diagnostic::Span>,
 }
 
 fn collect_task_group_async_lets(
@@ -586,6 +579,7 @@ where
         Expr::Ident(_, _)
         | Expr::Number(_, _)
         | Expr::String(_, _)
+        | Expr::CharLiteral(_, _)
         | Expr::MultilineString(_, _)
         | Expr::Unknown(_) => {}
     }
@@ -974,6 +968,7 @@ fn find_nested_task_group_await_span_expr<'a>(
         Expr::Ident(_, _)
         | Expr::Number(_, _)
         | Expr::String(_, _)
+        | Expr::CharLiteral(_, _)
         | Expr::MultilineString(_, _)
         | Expr::Unknown(_) => None,
     }
@@ -1467,6 +1462,7 @@ fn expr_first_cancellation_token(expr: &Expr) -> Option<crate::diagnostic::Span>
         | Expr::Ident(..)
         | Expr::Number(..)
         | Expr::String(..)
+        | Expr::CharLiteral(..)
         | Expr::MultilineString(..)
         | Expr::Unknown(_) => None,
     }
@@ -1534,6 +1530,7 @@ fn expr_first_await(expr: &Expr) -> Option<crate::diagnostic::Span> {
         Expr::Ident(..)
         | Expr::Number(..)
         | Expr::String(..)
+        | Expr::CharLiteral(..)
         | Expr::MultilineString(..)
         | Expr::Unknown(_) => None,
     }
@@ -1816,6 +1813,7 @@ fn hir_expr_type_name(expr: &HirExpr) -> Option<&str> {
         HirExpr::Field { access, .. } => access.type_name.as_deref(),
         HirExpr::Number { value, .. } => Some(crate::hir::number_literal_type_name(value)),
         HirExpr::String { .. } => Some("String"),
+        HirExpr::Char { .. } => Some("Char"),
         HirExpr::Binary { .. } | HirExpr::Index { .. } => None,
         HirExpr::ObjectLiteral { .. }
         | HirExpr::ArrayLiteral { .. }
@@ -1909,7 +1907,7 @@ fn callee_display(callee: &Callee) -> String {
 fn analyzer_expr_label(expr: &Expr) -> String {
     match expr {
         Expr::Ident(name, _) => name.clone(),
-        Expr::String(value, _) | Expr::MultilineString(value, _) => format!("{value:?}"),
+        Expr::String(value, _) | Expr::CharLiteral(value, _) | Expr::MultilineString(value, _) => format!("{value:?}"),
         Expr::Field { base, name, .. } => format!("{}.{}", analyzer_expr_label(base), name),
         Expr::Index { base, .. } => format!("{}[]", analyzer_expr_label(base)),
         Expr::Call { callee, .. } => format!("{}()", callee_display(callee)),

crates/rsscript/src/analyzer/assign.rs

@@ -255,6 +255,7 @@ impl<'a> AssignChecker<'a> {
             | Expr::Ident(..)
             | Expr::Number(..)
             | Expr::String(..)
+            | Expr::CharLiteral(..)
             | Expr::MultilineString(..)
             | Expr::Unknown(_) => {}
         }

crates/rsscript/src/analyzer/exhaustiveness.rs

@@ -587,6 +587,7 @@ impl Analyzer<'_> {
             | HirExpr::Ident { .. }
             | HirExpr::Number { .. }
             | HirExpr::String { .. }
+            | HirExpr::Char { .. }
             | HirExpr::Unknown(_) => {}
         }
     }

crates/rsscript/src/analyzer/resource_types.rs

@@ -348,6 +348,7 @@ impl Analyzer<'_> {
             | Expr::Ident(_, _)
             | Expr::Number(_, _)
             | Expr::String(_, _)
+            | Expr::CharLiteral(_, _)
             | Expr::MultilineString(_, _)
             | Expr::Unknown(_) => {}
         }
@@ -481,6 +482,7 @@ impl Analyzer<'_> {
             | Expr::Ident(_, _)
             | Expr::Number(_, _)
             | Expr::String(_, _)
+            | Expr::CharLiteral(_, _)
             | Expr::MultilineString(_, _)
             | Expr::Unknown(_) => {}
         }

crates/rsscript/src/analyzer/runtime_guarantee.rs

@@ -249,6 +249,7 @@ impl Analyzer<'_> {
             | Expr::Ident(_, _)
             | Expr::Number(_, _)
             | Expr::String(_, _)
+            | Expr::CharLiteral(_, _)
             | Expr::MultilineString(_, _)
             | Expr::Unknown(_) => {}
         }

crates/rsscript/src/analyzer/syntax_support.rs

@@ -2,19 +2,6 @@ use super::*;
 
 impl Analyzer<'_> {
     pub(super) fn check_unsupported_syntax(&mut self) {
-        // A `'...'` character-literal attempt lexes to one `Symbol("'")` token.
-        // Report it once with a clear message and remember its span so the
-        // generic `Expr::Unknown` walk below does not emit a duplicate RS0015 for
-        // the same lone `'` operand.
-        let char_literal_spans = self.syntax_program.char_literal_spans.clone();
-        self.char_literal_spans = char_literal_spans.iter().cloned().collect();
-        for span in char_literal_spans {
-            self.unsupported_syntax(
-                span,
-                "character literal",
-                "RSScript has no character-literal syntax. Use a String literal (\"x\") or compare code points with Char.to_code(...).",
-            );
-        }
         for span in self.syntax_program.unknown_top_level_spans.clone() {
             self.unsupported_syntax(
                 span,
@@ -502,18 +489,14 @@ impl Analyzer<'_> {
             Expr::Ident(_, _)
             | Expr::Number(_, _)
             | Expr::String(_, _)
+            | Expr::CharLiteral(_, _)
             | Expr::MultilineString(_, _) => {}
             Expr::Unknown(span) => {
-                // A lone `'` operand from a character-literal attempt already got
-                // the targeted "character literal" diagnostic; do not also emit
-                // the generic unsupported-expression RS0015 for it.
-                if !self.char_literal_spans.contains(span) {
-                    self.unsupported_syntax(
-                        span.clone(),
-                        "unsupported expression",
-                        "This expression is outside the current RSScript parser surface.",
-                    );
-                }
+                self.unsupported_syntax(
+                    span.clone(),
+                    "unsupported expression",
+                    "This expression is outside the current RSScript parser surface.",
+                );
             }
         }
     }

crates/rsscript/src/analyzer/unknowns.rs

@@ -318,6 +318,7 @@ impl Analyzer<'_> {
             | HirExpr::ArrayLiteral { .. }
             | HirExpr::Number { .. }
             | HirExpr::String { .. }
+            | HirExpr::Char { .. }
             | HirExpr::Unknown(_) => {}
         }
     }

crates/rsscript/src/checks/body/async_checks.rs

@@ -157,6 +157,7 @@ pub(super) fn check_await_placement_expr(
         HirExpr::Ident { .. }
         | HirExpr::Number { .. }
         | HirExpr::String { .. }
+        | HirExpr::Char { .. }
         | HirExpr::Unknown(_) => {}
     }
 }
@@ -262,6 +263,7 @@ pub(super) fn expr_span(expr: &HirExpr) -> &Span {
         HirExpr::Ident { span, .. }
         | HirExpr::Number { span, .. }
         | HirExpr::String { span, .. }
+        | HirExpr::Char { span, .. }
         | HirExpr::ObjectLiteral { span, .. }
         | HirExpr::MapLiteral { span, .. }
         | HirExpr::ArrayLiteral { span, .. }

crates/rsscript/src/checks/body/binding.rs

@@ -356,7 +356,7 @@ pub(super) fn collect_expr_uses(expr: &HirExpr, uses: &mut HashSet<String>) {
                 collect_expr_uses(item, uses);
             }
         }
-        HirExpr::Number { .. } | HirExpr::String { .. } | HirExpr::Unknown(_) => {}
+        HirExpr::Number { .. } | HirExpr::String { .. } | HirExpr::Char { .. } | HirExpr::Unknown(_) => {}
     }
 }
 
@@ -416,7 +416,7 @@ pub(super) fn collect_await_operand_live_uses(expr: &HirExpr, uses: &mut HashSet
                 collect_await_operand_live_uses(item, uses);
             }
         }
-        HirExpr::Number { .. } | HirExpr::String { .. } | HirExpr::Unknown(_) => {}
+        HirExpr::Number { .. } | HirExpr::String { .. } | HirExpr::Char { .. } | HirExpr::Unknown(_) => {}
     }
 }
 

crates/rsscript/src/checks/body/closure_captures.rs

@@ -149,6 +149,7 @@ pub(super) fn check_explicit_closure_captures_expr(
         HirExpr::Ident { .. }
         | HirExpr::Number { .. }
         | HirExpr::String { .. }
+        | HirExpr::Char { .. }
         | HirExpr::Unknown(_) => {}
     }
 }
@@ -479,6 +480,7 @@ pub(super) fn collect_syntax_expr_bindings(expr: &Expr, names: &mut HashSet<Stri
         Expr::Ident(_, _)
         | Expr::Number(_, _)
         | Expr::String(_, _)
+        | Expr::CharLiteral(_, _)
         | Expr::MultilineString(_, _)
         | Expr::Unknown(_) => {}
     }
@@ -744,6 +746,7 @@ pub(super) fn check_explicit_closure_capture_effects_syntax_expr(
         Expr::Ident(_, _)
         | Expr::Number(_, _)
         | Expr::String(_, _)
+        | Expr::CharLiteral(_, _)
         | Expr::MultilineString(_, _)
         | Expr::Unknown(_) => {}
     }
@@ -912,6 +915,7 @@ pub(super) fn collect_syntax_capture_effects_expr(
         }
         Expr::Number(_, _)
         | Expr::String(_, _)
+        | Expr::CharLiteral(_, _)
         | Expr::MultilineString(_, _)
         | Expr::Unknown(_) => {}
     }