refactor(gc): Deduplicate IterFrame and SyncFrame val traversal.

Author: dylan-sutton-chavez

compiler/src/modules/vm/gc.rs

@@ -6,18 +6,7 @@ impl<'a> VM<'a> {
     /* Mark all reachable roots then sweep; non-heap Vals are no-op to mark. */
     pub(crate) fn collect(&mut self, current_slots: &[Val]) {
         for &v in &self.stack { self.heap.mark(v); }
-        for sf in &self.pending_sync_frames {
-            for &v in &sf.slots { self.heap.mark(v); }
-            for &v in &sf.stack_delta { self.heap.mark(v); }
-            for fr in &sf.iter_delta {
-                match fr {
-                    IterFrame::Seq { items, .. } => for &v in items { self.heap.mark(v); },
-                    IterFrame::Coroutine(v) => self.heap.mark(*v),
-                    IterFrame::UserDefined(v) => self.heap.mark(*v),
-                    IterFrame::Range { .. } => {}
-                }
-            }
-        }
+        for sf in &self.pending_sync_frames { sf.for_each_val(&mut |v| heap.mark(v)); }
         for &v in &self.with_stack { self.heap.mark(v); }
         for &v in &self.yields { self.heap.mark(v); }
         for &v in &self.event_queue { self.heap.mark(v); }
@@ -40,16 +29,9 @@ impl<'a> VM<'a> {
         }
         for &v in self.globals.values() { self.heap.mark(v); }
         for &v in self.module_state.values() { self.heap.mark(v); }
-        for frame in &self.iter_stack {
-            match frame {
-                IterFrame::Seq { items, .. } => {
-                    for &v in items { self.heap.mark(v); }
-                }
-                IterFrame::Coroutine(v) => self.heap.mark(*v),
-                IterFrame::UserDefined(v) => self.heap.mark(*v),
-                IterFrame::Range { .. } => {}
-            }
-        }
+        let heap = &mut self.heap; // split borrow: lets closures take &mut heap while iterating other fields
+        for frame in &self.iter_stack { frame.for_each_val(&mut |v| heap.mark(v)); }
+        for sf in &self.pending_sync_frames { sf.for_each_val(&mut |v| heap.mark(v)); }
         for cache in self.opcode_caches.values() {
             if let Some(consts) = cache.const_vals_opt() {
                 for &v in consts { self.heap.mark(v); }

compiler/src/modules/vm/types/coro.rs

@@ -106,4 +106,22 @@ impl IterFrame {
             }
         }
     }
+
+    /* Visit each Val in this frame; Range holds none. */
+    pub(crate) fn for_each_val(&self, f: &mut impl FnMut(Val)) {
+        match self {
+            IterFrame::Seq { items, .. } => for &v in items { f(v); },
+            Self::Coroutine(v) | Self::UserDefined(v) => f(*v),
+            IterFrame::Range { .. } => {}
+        }
+    }
+}
+
+impl SyncFrame {
+    /* Visit all Vals across slots, stack delta, and iter frames. */
+    pub(crate) fn for_each_val(&self, f: &mut impl FnMut(Val)) {
+        for &v in &self.slots { f(v); }
+        for &v in &self.stack_delta { f(v); }
+        for fr in &self.iter_delta { fr.for_each_val(f); }
+    }
 }

compiler/src/modules/vm/types/mod.rs

@@ -315,22 +315,8 @@ pub(crate) fn for_each_val(obj: &HeapObj, mut f: impl FnMut(Val)) {
         HeapObj::Coroutine(_, slots, stack, _, iters, sub_frames, _) => {
             for &v in slots { f(v); }
             for &v in stack { f(v); }
-            for fr in iters { match fr {
-                IterFrame::Seq { items, .. } => for &v in items { f(v); },
-                IterFrame::Coroutine(v) => f(*v),
-                IterFrame::UserDefined(v) => f(*v),
-                IterFrame::Range { .. } => {}
-            }}
-            for sf in sub_frames {
-                for &v in &sf.slots { f(v); }
-                for &v in &sf.stack_delta { f(v); }
-                for fr in &sf.iter_delta { match fr {
-                    IterFrame::Seq { items, .. } => for &v in items { f(v); },
-                    IterFrame::Coroutine(v) => f(*v),
-                    IterFrame::UserDefined(v) => f(*v),
-                    IterFrame::Range { .. } => {}
-                }}
-            }
+            for fr in iters { fr.for_each_val(f); }
+            for sf in sub_frames { sf.for_each_val(f); }
         }
         HeapObj::Func(_, defaults, captures) => {
             for &v in defaults { f(v); }