perf(vm): copy-on-write struct field writes

SetField previously cloned the entire field map and allocated a new
Rc<VmStruct> on every `obj.field = ...` (value semantics via rebuild) —
the dominant cost in mut-binding field-write loops.

Now write_field_value_owned takes the struct out of its register and
mutates in place via Rc::get_mut when the Rc is uniquely owned (no other
observer → observationally identical to rebuilding); it copy-on-writes
(clone + rebuild) only when the Rc is shared. struct_field_rw benchmark:
~141ms → ~86ms.

Gated by a new 5-way differential test (backends_agree_on_struct_field_writes)
covering the in-place loop + read-parameter sharing; full suite green.

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

Author: Haofei

src/reg_vm/mod.rs

@@ -6000,7 +6000,11 @@ impl RegVm {
             } => {
                 let obj_reg = base + *obj;
                 let new_value = self.reg(base + *value).clone();
-                let updated = write_field_value(self.reg(obj_reg), name, new_value)?;
+                // Take the struct out so its `Rc` count reflects only other live
+                // holders; `write_field_value_owned` then mutates in place when
+                // uniquely owned, or copy-on-writes when shared.
+                let current = self.take_reg(obj_reg);
+                let updated = write_field_value_owned(current, name, new_value)?;
                 self.set_reg(obj_reg, updated);
                 self.set_reg(base + *dst, VmValue::Unit);
             }

src/reg_vm/value_convert.rs

@@ -333,33 +333,31 @@ pub(super) fn read_field_ref(value: &VmValue, field: &str) -> Result<VmValue, Ev
 /// Return a copy of the struct/variant `value` with `field` set to `new_value`.
 /// Structs are value types, so this rebuilds the struct. A `Managed` wrapper is
 /// updated in place (its interior is shared and mutable by design).
-pub(super) fn write_field_value(
-    value: &VmValue,
+/// Set `field`, mutating the struct in place when the value is the sole owner of
+/// its `Rc` (copy-on-write). A uniquely-owned struct has no other observer, so
+/// in-place mutation is observationally identical to rebuilding — but avoids
+/// cloning the entire field map and allocating a new `Rc` on every `obj.field =
+/// ...` (the dominant cost in `mut`-binding field-write loops). Falls back to
+/// clone + rebuild when the `Rc` is shared.
+pub(super) fn write_field_value_owned(
+    value: VmValue,
     field: &str,
     new_value: VmValue,
 ) -> Result<VmValue, EvalError> {
     match value {
-        VmValue::Struct(data) | VmValue::Variant(data) => {
-            if !data.fields.contains_key(field) {
-                return Err(EvalError::Runtime(format!(
-                    "reg VM struct value is missing field `{field}`."
-                )));
-            }
-            let mut fields = data.fields.clone();
-            fields.insert(field.to_string(), new_value);
-            let updated = Rc::new(VmStruct {
-                name: Rc::clone(&data.name),
-                fields,
-            });
-            Ok(match value {
-                VmValue::Variant(_) => VmValue::Variant(updated),
-                _ => VmValue::Struct(updated),
-            })
+        VmValue::Struct(mut data) => {
+            write_struct_field_in_place(&mut data, field, new_value)?;
+            Ok(VmValue::Struct(data))
+        }
+        VmValue::Variant(mut data) => {
+            write_struct_field_in_place(&mut data, field, new_value)?;
+            Ok(VmValue::Variant(data))
         }
         VmValue::Managed(inner) => {
-            let updated = write_field_value(&inner.borrow(), field, new_value)?;
+            let current = inner.borrow().clone();
+            let updated = write_field_value_owned(current, field, new_value)?;
             *inner.borrow_mut() = updated;
-            Ok(VmValue::Managed(Rc::clone(inner)))
+            Ok(VmValue::Managed(inner))
         }
         other => Err(EvalError::Runtime(format!(
             "reg VM expected Struct for field `{field}`, got `{}`.",
@@ -368,6 +366,37 @@ pub(super) fn write_field_value(
     }
 }
 
+fn write_struct_field_in_place(
+    data: &mut Rc<VmStruct>,
+    field: &str,
+    new_value: VmValue,
+) -> Result<(), EvalError> {
+    if let Some(unique) = Rc::get_mut(data) {
+        return match unique.fields.get_mut(field) {
+            Some(slot) => {
+                *slot = new_value;
+                Ok(())
+            }
+            None => Err(EvalError::Runtime(format!(
+                "reg VM struct value is missing field `{field}`."
+            ))),
+        };
+    }
+    // Shared `Rc`: copy-on-write to preserve value semantics for the other holders.
+    if !data.fields.contains_key(field) {
+        return Err(EvalError::Runtime(format!(
+            "reg VM struct value is missing field `{field}`."
+        )));
+    }
+    let mut fields = data.fields.clone();
+    fields.insert(field.to_string(), new_value);
+    *data = Rc::new(VmStruct {
+        name: Rc::clone(&data.name),
+        fields,
+    });
+    Ok(())
+}
+
 pub(super) fn unmanage_vm_value(value: VmValue) -> VmValue {
     match value {
         VmValue::Managed(value) => unmanage_vm_value(value.borrow().clone()),

tests/backend_differential.rs

@@ -382,6 +382,43 @@ fn main() -> Unit {
     common::differential::assert_backends_agree("jit-collections.rss", source, &[]);
 }
 
+/// A mut-heavy struct field-write loop plus mut/read parameter passing — gates the
+/// copy-on-write `SetField` (mutate in place when the struct `Rc` is uniquely
+/// owned, clone when shared). The results must match the compiled backend, which
+/// uses owned Rust structs.
+#[test]
+fn backends_agree_on_struct_field_writes() {
+    let source = "\
+struct Box {
+    v: Int,
+    w: Int
+}
+
+fn total(b: read Box) -> Int {
+    return b.v + b.w
+}
+
+fn main() -> Unit {
+    let mut a = Box(v: 1, w: 2)
+    let mut i = 0
+    while i < 20 {
+        a.v = a.v + a.w
+        a.w = a.w + i + a.v
+        // `total` borrows `a` (read) mid-loop — exercises the shared-Rc path
+        // before the next in-place write.
+        let snapshot = total(b: read a)
+        a.v = a.v + snapshot
+        i = i + 1
+    }
+    Log.write(message: read String.from_int(value: a.v))
+    Log.write(message: read String.from_int(value: a.w))
+    Log.write(message: read String.from_int(value: total(b: read a)))
+    return Unit
+}
+";
+    common::differential::assert_backends_agree("struct-field-writes.rss", source, &[]);
+}
+
 /// Deque / Set / SortedSet / SortedMap mutations with out-of-order inserts,
 /// duplicates, and removes, then sorted/ordered dumps. This gates the collection
 /// backing/representation optimizations: the VM (`Vec`-backed) and the compiled