perf(reg-vm): elision — scalar extraction never taints its source collection (Slice 1)

Generalizes the SH-022 Char-specific fix: a Copy scalar (Int/Bool/Float/
Char/...) has no interior Rc, so extracting it from a collection/struct/
variant cannot alias the source. Thread a scalar_regs bitset from the
lowerer into deepcopy_elidable_param_regs and skip the taint edge src->dst
for scalar extractions. All read List<Scalar> / Map<_,Scalar> / scalar-field
reads now elide their prologue DeepCopy, killing the O(n^2) copy class
independent of per-intrinsic classification.

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

Author: olwang

crates/rsscript/src/reg_vm/lower.rs

@@ -12,9 +12,45 @@ pub(crate) struct RegLowerer<'a> {
     /// `==`/`!=` could compare a closure-containing operand. Shared across all
     /// function lowerings so it summarizes the whole program.
     pub(crate) closure_identity_observable: &'a std::cell::Cell<bool>,
+    /// Registers proven to hold a `Copy` scalar (`Int`/`Bool`/`Float`/`Char`/…,
+    /// per [`scalar_param_type_needs_no_deep_copy`]). Such a value is inline with
+    /// no interior `Rc`, so extracting it from a collection/struct/variant cannot
+    /// alias the source. The DeepCopy-elision taint analysis reads this set to
+    /// avoid over-tainting an extraction's source collection (see
+    /// [`deepcopy_elidable_param_regs`]). Conservative by construction: a register
+    /// is only inserted when the extracted static type is a known scalar; absence
+    /// means "unknown", which keeps the (sound) over-tainting behavior.
+    pub(crate) scalar_regs: std::collections::HashSet<Reg>,
+}
+
+/// The element type produced by extracting from a collection type, or `None`
+/// when it cannot be determined (⇒ conservative: not marked scalar ⇒ copy kept).
+/// `List<T>`/`Deque<T>` → `T`; `Map<K, V>`/`SortedMap<K, V>` → `V` (the VALUE, the
+/// type `MapGet` yields). Any other root (or a missing generic arg) → `None`.
+fn list_elem_type(collection_ty: &str) -> Option<&str> {
+    let root = crate::text_util::type_root_name(collection_ty);
+    let args = crate::text_util::type_arg_names(collection_ty)?;
+    match root {
+        "List" | "Deque" => args.first().copied(),
+        "Map" | "SortedMap" => args.get(1).copied(),
+        _ => None,
+    }
 }
 
 impl RegLowerer<'_> {
+    /// Record that `dst` holds a `Copy` scalar when `elem_ty` is a known scalar
+    /// type (`Int`/`Bool`/`Float`/`Char`/…). Extracting such a value is a bit-copy
+    /// that cannot alias its source, so the elision taint analysis skips it. A
+    /// `None` / non-scalar `elem_ty` (e.g. `String`, unknown) leaves `dst`
+    /// unmarked — the sound, over-tainting default.
+    fn note_scalar(&mut self, dst: Reg, elem_ty: Option<&str>) {
+        if elem_ty.is_some_and(|ty| {
+            scalar_param_type_needs_no_deep_copy(crate::text_util::strip_fresh_type(ty))
+        }) {
+            self.scalar_regs.insert(dst);
+        }
+    }
+
     pub(crate) fn local(&mut self, name: &str) -> Reg {
         if let Some(reg) = self.function.local_regs.get(name) {
             return *reg;
@@ -502,6 +538,8 @@ impl RegLowerer<'_> {
                     list,
                     index,
                 });
+                let elem_ty = reg_expr_type_name(iterable).and_then(list_elem_type);
+                self.note_scalar(item, elem_ty);
 
                 self.loop_stack.push(LoopPatch {
                     cleanup_base: self.cleanup_stack.len(),
@@ -850,13 +888,18 @@ impl RegLowerer<'_> {
                         name: name.clone(),
                     });
                 }
+                // `access.type_name` is the field's own static type — the value
+                // this extraction yields — so it feeds `note_scalar` directly.
+                self.note_scalar(dst, access.type_name.as_deref());
                 Ok(dst)
             }
             HirExpr::Index { base, index, .. } => {
                 let list = self.expr(base)?;
+                let elem_ty = reg_expr_type_name(base).and_then(list_elem_type);
                 let index = self.expr(index)?;
                 let dst = self.temp();
                 self.emit(RegInstr::ListGet { dst, list, index });
+                self.note_scalar(dst, elem_ty);
                 Ok(dst)
             }
             HirExpr::Effect { value, .. } => self.expr(value),
@@ -927,6 +970,7 @@ impl RegLowerer<'_> {
                         loop_stack: Vec::new(),
                         cleanup_stack: Vec::new(),
                         closure_identity_observable: self.closure_identity_observable,
+                        scalar_regs: std::collections::HashSet::new(),
                     };
                     for capture in &capture_names {
                         lowerer.local(capture);
@@ -1244,6 +1288,11 @@ impl RegLowerer<'_> {
                                 dst,
                                 deque: arg_regs[0],
                             });
+                            let elem_ty = args
+                                .first()
+                                .and_then(|arg| reg_expr_type_name(&arg.value))
+                                .and_then(list_elem_type);
+                            self.note_scalar(dst, elem_ty);
                             return Ok(dst);
                         }
                         ("Deque", "pop_front") => {
@@ -1257,6 +1306,11 @@ impl RegLowerer<'_> {
                                 dst,
                                 deque: arg_regs[0],
                             });
+                            let elem_ty = args
+                                .first()
+                                .and_then(|arg| reg_expr_type_name(&arg.value))
+                                .and_then(list_elem_type);
+                            self.note_scalar(dst, elem_ty);
                             return Ok(dst);
                         }
                         ("Deque", "push_back") => {
@@ -1381,6 +1435,11 @@ impl RegLowerer<'_> {
                                 list: arg_regs[0],
                                 index: arg_regs[1],
                             });
+                            let elem_ty = args
+                                .first()
+                                .and_then(|arg| reg_expr_type_name(&arg.value))
+                                .and_then(list_elem_type);
+                            self.note_scalar(dst, elem_ty);
                             return Ok(dst);
                         }
                         ("List", "len") => {
@@ -1533,6 +1592,14 @@ impl RegLowerer<'_> {
                                 map: arg_regs[0],
                                 key: arg_regs[1],
                             });
+                            // `list_elem_type` returns the Map VALUE type (`V` of
+                            // `Map<K, V>`), which is what `MapGet` yields (as a
+                            // fresh `Option<V>` of a cloned value).
+                            let value_ty = args
+                                .first()
+                                .and_then(|arg| reg_expr_type_name(&arg.value))
+                                .and_then(list_elem_type);
+                            self.note_scalar(dst, value_ty);
                             return Ok(dst);
                         }
                         ("Map", "insert") => {

crates/rsscript/src/reg_vm/model.rs

@@ -398,7 +398,7 @@ pub(crate) fn closure_captures_all_scalar(closure: &VmClosure) -> bool {
     })
 }
 
-fn scalar_param_type_needs_no_deep_copy(type_name: &str) -> bool {
+pub(crate) fn scalar_param_type_needs_no_deep_copy(type_name: &str) -> bool {
     matches!(
         type_name,
         "Bool"
@@ -2481,7 +2481,11 @@ fn deepcopy_instr_forces_keep(instr: &RegInstr, tainted: &[bool], n_regs: usize)
 ///
 /// Correctness-critical: when in doubt the analysis keeps the copy. It runs one independent
 /// pass per root so a keep verdict is attributed to exactly the responsible parameter.
-fn deepcopy_elidable_param_regs(code: &[RegInstr], n_regs: usize) -> std::collections::HashSet<Reg> {
+fn deepcopy_elidable_param_regs(
+    code: &[RegInstr],
+    n_regs: usize,
+    scalar_regs: &std::collections::HashSet<Reg>,
+) -> std::collections::HashSet<Reg> {
     let roots: Vec<Reg> = code
         .iter()
         .filter_map(|instr| match instr {
@@ -2500,16 +2504,38 @@ fn deepcopy_elidable_param_regs(code: &[RegInstr], n_regs: usize) -> std::collec
         while changed {
             changed = false;
             for instr in code {
-                if let RegInstr::Move { dst, src }
-                | RegInstr::ListGet { dst, list: src, .. }
+                // A `Move` copies the value whole, so taint always flows (a scalar
+                // dst is harmless — a never-tainted scalar already yields the right
+                // verdict, but a `Move` of a heap value must propagate).
+                if let RegInstr::Move { dst, src } = instr {
+                    if *src < n_regs && *dst < n_regs && tainted[*src] && !tainted[*dst] {
+                        tainted[*dst] = true;
+                        changed = true;
+                    }
+                }
+                // Extractions (`ListGet`/`MapGet`/`GetField`/`GetFieldSlot`/
+                // `UnwrapVariantValue`/`DequePop*`) pull an INTERIOR value out of a
+                // collection/struct/variant. When the lowerer proved `dst` holds a
+                // `Copy` scalar (`Int`/`Bool`/`Float`/`Char`/…), that value is inline
+                // with no interior `Rc`: it cannot alias `src` or carry `src`'s `Rc`
+                // into an escape, so the taint must NOT flow — that spurious edge is
+                // exactly what forced the O(n²) copy-keep for per-element helpers.
+                // Absence from `scalar_regs` (unknown/`String`/`Bytes`/`Json`/heap)
+                // keeps the sound over-tainting behavior.
+                else if let RegInstr::ListGet { dst, list: src, .. }
                 | RegInstr::MapGet { dst, map: src, .. }
                 | RegInstr::GetField { dst, base: src, .. }
                 | RegInstr::GetFieldSlot { dst, base: src, .. }
                 | RegInstr::UnwrapVariantValue { dst, src, .. }
                 | RegInstr::DequePopFront { dst, deque: src }
                 | RegInstr::DequePopBack { dst, deque: src } = instr
                 {
-                    if *src < n_regs && *dst < n_regs && tainted[*src] && !tainted[*dst] {
+                    if *src < n_regs
+                        && *dst < n_regs
+                        && tainted[*src]
+                        && !tainted[*dst]
+                        && !scalar_regs.contains(dst)
+                    {
                         tainted[*dst] = true;
                         changed = true;
                     }
@@ -2608,6 +2634,7 @@ impl RegUnit {
                 loop_stack: Vec::new(),
                 cleanup_stack: Vec::new(),
                 closure_identity_observable: &closure_identity_observable,
+                scalar_regs: std::collections::HashSet::new(),
             };
             for param in &signature.params {
                 let reg = lowerer.local(&param.name);
@@ -2635,7 +2662,8 @@ impl RegUnit {
             // byte-identical to before.
             if elide_deepcopy_enabled() {
                 let n_regs = lowerer.function.regs;
-                let elidable = deepcopy_elidable_param_regs(&lowerer.function.code, n_regs);
+                let elidable =
+                    deepcopy_elidable_param_regs(&lowerer.function.code, n_regs, &lowerer.scalar_regs);
                 for instr in lowerer.function.code.iter_mut() {
                     if let RegInstr::DeepCopy { reg } = instr {
                         if elidable.contains(reg) {
@@ -2672,6 +2700,7 @@ impl RegUnit {
                 loop_stack: Vec::new(),
                 cleanup_stack: Vec::new(),
                 closure_identity_observable: &closure_identity_observable,
+                scalar_regs: std::collections::HashSet::new(),
             };
             if let Some(info) = hir.type_info(type_name) {
                 for field in &info.fields_ordered {

crates/rsscript/src/reg_vm/tests.rs

@@ -709,6 +709,68 @@ fn main() -> Unit {
         assert_eq!(output.stdout, "98\n");
     }
 
+    /// Slice 1 generalization (beyond SH-022's Char special-case): a `read
+    /// List<Int>` param whose extracted elements are RETURNED (a keep-forcing use)
+    /// must still have its prologue `DeepCopy` ELIDED. Extracting a `Copy` scalar
+    /// (`Int`) can no longer taint its source collection, so the returned element
+    /// is untainted and nothing pins the copy — even though `Return` of a tainted
+    /// register WOULD force a keep. This is the general kill for the O(n^2)
+    /// `read List<Scalar>` copy class, independent of any per-scalar intrinsic
+    /// classification. No `Char.*` (or any) intrinsic on the element is involved.
+    #[test]
+    fn deepcopy_elision_fires_for_int_list_read_param() {
+        let source = r#"
+features: local
+
+fn scan(xs: read List<Int>, i: Int) -> Int {
+    let a = List.get<Int>(list: read xs, index: i)
+    let b = List.get<Int>(list: read xs, index: i + 1)
+    if a > b {
+        return a
+    }
+    return b
+}
+
+fn main() -> Unit {
+    local xs = List.new<Int>()
+    List.push<Int>(list: mut xs, value: read 3)
+    List.push<Int>(list: mut xs, value: read 7)
+    Log.write(message: read String.from_int(value: scan(xs: read xs, i: 0)))
+    return Unit
+}
+"#;
+        let executable =
+            reg_vm_compile_source("deepcopy-elision-int.rss", source).expect("lowering succeeds");
+
+        let scan_id = executable.unit.function_ids["scan"];
+        let scan = executable.unit.functions[scan_id].as_ref();
+        let elided = scan
+            .code
+            .iter()
+            .filter(|instr| matches!(instr, RegInstr::DeepCopyElided { .. }))
+            .count();
+        let eager = scan
+            .code
+            .iter()
+            .filter(|instr| matches!(instr, RegInstr::DeepCopy { .. }))
+            .count();
+        if crate::reg_vm::model::elide_deepcopy_enabled_for_test() {
+            assert!(
+                elided >= 1 && eager == 0,
+                "elision ON: `read List<Int>` param whose extracted elements are \
+                 returned must be elided (scalar extraction must not taint the list), \
+                 got {elided} elided / {eager} eager: {:#?}",
+                scan.code,
+            );
+        }
+
+        // Elision must not change behavior: max(xs[0], xs[1]) == max(3, 7) == 7.
+        let output = executable
+            .eval_main_with_args(Vec::<String>::new())
+            .expect("program should still run");
+        assert_eq!(output.stdout, "7\n");
+    }
+
     #[test]
     fn jit_runs_scalar_self_recursion_on_flat_executor() {
         let source = r#"

docs/ledgers/rss-selfhost-ledger.md

@@ -658,6 +658,30 @@ gap is VM value-representation / intrinsic-dispatch cost (the next big lever).
   (regression guard). Full differential + compiled-parity green (elision soundness).
 - **Status:** fixed (O(n²) removed; residual ~46× is the general VM per-op tax,
   tracked by the parked perf roadmap).
+- **GENERALIZED — Slice 1 of borrow-by-default (2026-07-01):** the SH-022 fix was
+  intrinsic-specific (it re-classified the 12 `Char.*` intrinsics so a tainted
+  extracted `Char` stopped pinning the copy). The general root cause was that the
+  taint pass OVER-tainted: extracting a `Copy` scalar (`Int`/`Bool`/`Float`/`Char`/…)
+  from a collection/struct/variant (`ListGet`/`MapGet`/`GetField`/`GetFieldSlot`/
+  `UnwrapVariantValue`/`DequePop*`) tainted the whole source, so ANY keep-forcing
+  use of the scalar (a `Return`, a store, an unclassified intrinsic) pinned the copy
+  → the same O(n²) class for every `read List<Scalar>` / `Map<_, Scalar>` /
+  scalar-field read, not just Char. **Fix:** a `Copy` scalar has no interior `Rc`,
+  so extracting one (a bit-copy; for `MapGet`/`DequePop*` a fresh `Option<Scalar>`
+  of a `.cloned()` scalar) cannot alias the source or carry its `Rc` into an escape.
+  The lowerer (which has HIR types) now threads a `scalar_regs` bitset — populated at
+  each extractor site whose extracted static type is a known scalar — into
+  `deepcopy_elidable_param_regs`, which SKIPS the taint edge `src→dst` for scalar
+  extractions (`Move` is unchanged; non-scalar values like `String`/`Bytes`/`Json`/
+  `List<T>` still taint, since their `.cloned()` shares the `Rc`). Now ALL
+  `read List<Scalar>` / `Map<_, Scalar>` / scalar-field reads elide their prologue
+  `DeepCopy`, independent of any per-intrinsic classification. Sound: over-tainting
+  was only a pessimization; the three `does_not_leak` JIT-acceptance guards stay
+  green. Perf holds at 45.9× (no regression). Sites NOT marked (conservative keep,
+  sound): list-pattern element extractions, variant-payload unwraps, and
+  struct-field pattern binds — pattern lowering does not thread the scrutinee's
+  static type, so those extractions keep the (sound) over-taint. New regression
+  guard: `reg_vm::tests::…::deepcopy_elision_fires_for_int_list_read_param`.
 
 ### SH-023 — self-hosted checker reaches RS0005 parity at declaration level; the merged callable namespace is the load-bearing rule