fix(reg-vm,analyzer): stream cursor write-back + None exhaustiveness arm

Two pre-existing bugs found during the module decomposition (both fail on
9447c41, neither refactor-induced):

- reg-VM Stream: expect_stream_ref materialized a detached copy of the
  struct's items list, so Stream.next's head-removal mutated a throwaway and
  never advanced the cursor seen by a later collect_list/next on the same
  stream. Share the underlying Rc<RefCell<TypedVec>> so the advance writes
  back through every read-clone of the stream, matching the interpreter.
  Fixes reg_vm_runs_cancellation_and_stream_intrinsics_like_interpreter.

- analyzer: a leftover private builtin_value_type_name copy lacked the
  "None" => Option arm the canonical checks::shared copy carries, so a bare
  `None` match scrutinee fell back to the constructor-name path and a
  wildcard-only match was spuriously reported non-exhaustive (RS0021).
  Delete the duplicate; reuse checks::shared::builtin_value_type_name.

Regression test: checker_accepts_wildcard_match_on_bare_none_literal.

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

Author: olwang

crates/rsscript/src/analyzer.rs

@@ -1814,7 +1814,7 @@ fn hir_expr_type_name(expr: &HirExpr) -> Option<&str> {
             name, type_name, ..
         } => type_name
             .as_deref()
-            .or_else(|| builtin_value_type_name(name)),
+            .or_else(|| crate::checks::shared::builtin_value_type_name(name)),
         HirExpr::Call { type_name, .. }
         | HirExpr::Effect { type_name, .. }
         | HirExpr::Manage { type_name, .. }
@@ -1834,15 +1834,6 @@ fn hir_expr_type_name(expr: &HirExpr) -> Option<&str> {
     }
 }
 
-fn builtin_value_type_name(name: &str) -> Option<&'static str> {
-    match name {
-        "true" | "false" => Some("Bool"),
-        "null" => Some("JsonLiteral"),
-        "Unit" => Some("Unit"),
-        _ => None,
-    }
-}
-
 fn constructor_pattern_is_irrefutable(pattern: &MatchPattern) -> bool {
     match pattern {
         MatchPattern::Binding { .. } | MatchPattern::Wildcard(_) => true,

crates/rsscript/src/reg_vm/intrinsics/mod.rs

@@ -2355,7 +2355,8 @@ impl RegVm {
                         "stream collect_list would block on an open channel stream",
                     )));
                 }
-                let values = stream.items.borrow_mut().drain(..).collect::<Vec<_>>();
+                let values = stream.items.borrow().to_vec();
+                stream.items.borrow_mut().clear();
                 Ok(value_ok(VmValue::List(Rc::new(RefCell::new(TypedVec::from_values(values))))))
             }
             RegIntrinsic::StreamFromList => {

crates/rsscript/src/reg_vm/resources.rs

@@ -408,7 +408,7 @@ pub(super) fn stream_collect_error_value(message: impl Into<String>) -> VmValue
 
 #[derive(Debug, Clone)]
 pub(super) struct VmStreamState {
-    pub(super) items: Rc<RefCell<Vec<VmValue>>>,
+    pub(super) items: Rc<RefCell<TypedVec>>,
     pub(super) collect_error: Option<String>,
     pub(super) channel_id: Option<i64>,
 }

crates/rsscript/src/reg_vm/value_access.rs

@@ -218,14 +218,15 @@ pub(super) fn expect_resource_pool_ref(value: &VmValue) -> Result<VmResourcePool
 pub(super) fn expect_stream_ref(value: &VmValue) -> Result<VmStreamState, EvalError> {
     match value {
         VmValue::Struct(data) if data.name().as_ref() == "Stream" => {
-            let items_list = data
+            // Share the struct's underlying items list (an `Rc<RefCell<TypedVec>>`)
+            // rather than copying it: `Stream.next` removes the head element, and a
+            // `read stream` clone of the struct shares this same `Rc`, so the cursor
+            // advance must write back through it to be visible to a later
+            // `collect_list`/`next` on the same stream.
+            let items = data
                 .get("items")
                 .ok_or_else(|| EvalError::Runtime("Stream value is missing items.".to_string()))
                 .and_then(expect_list_ref)?;
-            // The stream buffer is a plain `Vec<VmValue>`; materialize the typed
-            // list's logical values into one (TV1: a `Floats`/`Ints` list yields the
-            // same `VmValue` sequence a `Boxed` list would).
-            let items = Rc::new(RefCell::new(items_list.borrow().to_vec()));
             let collect_error = data
                 .get("collect_error")
                 .map(option_payload_value)

crates/rsscript/tests/checker_frontend/types.rs

@@ -1252,6 +1252,31 @@ fn pick() -> Int {
     ));
 }
 
+#[test]
+fn checker_accepts_wildcard_match_on_bare_none_literal() {
+    // A bare `None` scrutinee resolves to `Option`, so a wildcard arm is
+    // exhaustive. Regression: the analyzer's exhaustiveness helper formerly
+    // failed to classify `None` as `Option` (its `builtin_value_type_name`
+    // copy lacked the `None` arm the canonical `checks::shared` copy carries),
+    // so it fell back to the constructor-name path and spuriously reported the
+    // wildcard match as non-exhaustive.
+    let source = r#"
+fn pick() -> Int {
+    match None {
+        _ => return 0
+    }
+}
+"#;
+    let diagnostics = analyze_source("match-bare-none-wildcard.rss", source);
+
+    assert!(
+        !diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.code == "RS0021"),
+        "wildcard arm covers a bare `None` scrutinee; got {diagnostics:?}"
+    );
+}
+
 #[test]
 fn checker_reports_non_exhaustive_sum_type_match() {
     let source = r#"