GC refactoring for closures

Author: maximecb

src/closure.rs

@@ -0,0 +1,44 @@
+use crate::ast::FunId;
+use crate::vm::Value;
+use crate::alloc::Alloc;
+
+pub struct Closure
+{
+    pub fun_id: FunId,
+    slots: *mut [Value],
+}
+
+impl Closure
+{
+    /// Allocate a new closure with a given number of slots
+    pub fn new(fun_id: FunId, num_slots: usize, alloc: &mut Alloc) -> Result<Value, ()>
+    {
+        // Allocate the slots for the closure
+        let slots = alloc.alloc_table::<Value>(num_slots)?;
+
+        // Create the closure struct
+        let obj = Closure { fun_id, slots };
+
+        // Allocate the Object struct itself
+        let obj_ptr = alloc.alloc(obj)?;
+
+        Ok(Value::Closure(obj_ptr))
+    }
+
+    pub fn num_slots(&self) -> usize
+    {
+        unsafe { (&*self.slots).len() }
+    }
+
+    // Get the given closure slot value
+    pub fn get(&self, idx: usize) -> Value
+    {
+        unsafe { (*self.slots)[idx] }
+    }
+
+    // Set the value of a given closure slot
+    pub fn set(&mut self, idx: usize, val: Value)
+    {
+        unsafe { (*self.slots)[idx] = val }
+    }
+}

src/deepcopy.rs

@@ -3,7 +3,8 @@ use std::hash::{Hash, Hasher};
 use std::mem;
 use crate::alloc::Alloc;
 use crate::object::Object;
-use crate::vm::{Value, Closure};
+use crate::closure::Closure;
+use crate::vm::Value;
 
 /// Custom Hash implementation for Value
 impl Hash for Value
@@ -94,23 +95,17 @@ pub fn deepcopy(
             }
 
             Value::Closure(p) => {
-                let new_clos = unsafe { (*p).clone() };
+                let clos = unsafe { &*p };
+                let mut new_clos = Closure::new(clos.fun_id, clos.num_slots(), dst_alloc)?;
+                let mut new_clos = new_clos.unwrap_clos();
 
-                for val in &new_clos.slots {
-                    push_val!(val);
-                }
-
-                Value::Closure(dst_alloc.alloc(new_clos)?)
-            }
-
-            Value::Dict(p) => {
-                let new_obj = unsafe { (*p).clone() };
-
-                for val in new_obj.hash.values() {
-                    push_val!(val);
+                for i in 0..clos.num_slots() {
+                    let val = clos.get(i);
+                    new_clos.set(i, val);
+                    push_val!(&val);
                 }
 
-                Value::Dict(dst_alloc.alloc(new_obj)?)
+                Value::Closure(new_clos)
             }
 
             Value::Object(p) => {
@@ -127,6 +122,16 @@ pub fn deepcopy(
                 Value::Object(new_obj)
             }
 
+            Value::Dict(p) => {
+                let new_obj = unsafe { (*p).clone() };
+
+                for val in new_obj.hash.values() {
+                    push_val!(val);
+                }
+
+                Value::Dict(dst_alloc.alloc(new_obj)?)
+            }
+
             Value::Array(p) => {
                 let arr = unsafe { &*p };
                 let new_arr = arr.clone(dst_alloc)?;
@@ -175,15 +180,10 @@ pub fn remap(dst_map: &mut HashMap<Value, Value>)
 
             Value::Closure(p) => {
                 let clos = unsafe { &mut **p };
-                for slot_val in &mut clos.slots {
-                    remap_val!(slot_val);
-                }
-            }
-
-            Value::Dict(p) => {
-                let dict = unsafe { &mut **p };
-                for val in dict.hash.values_mut() {
-                    remap_val!(val);
+                for i in 0..clos.num_slots() {
+                    let mut val = clos.get(i);
+                    remap_val!(&mut val);
+                    clos.set(i, val);
                 }
             }
 
@@ -196,6 +196,14 @@ pub fn remap(dst_map: &mut HashMap<Value, Value>)
                 }
             }
 
+
+            Value::Dict(p) => {
+                let dict = unsafe { &mut **p };
+                for val in dict.hash.values_mut() {
+                    remap_val!(val);
+                }
+            }
+
             Value::Array(p) => {
                 let arr = unsafe { &mut **p };
                 for val in arr.items_mut() {

src/main.rs

@@ -13,6 +13,7 @@ mod codegen;
 mod vm;
 mod alloc;
 mod object;
+mod closure;
 mod array;
 mod bytearray;
 mod runtime;

src/object.rs

@@ -10,16 +10,6 @@ pub struct Object
 
 impl Object
 {
-    /*
-    pub fn new(class_id: ClassId, slots: *mut [Value]) -> Self
-    {
-        Object {
-            class_id,
-            slots,
-        }
-    }
-    */
-
     /// Allocate a new object with a given number of slots
     pub fn new(class_id: ClassId, num_slots: usize, alloc: &mut Alloc) -> Result<Value, ()>
     {

src/vm.rs

@@ -7,6 +7,7 @@ use crate::lexer::SrcPos;
 use crate::ast::{Program, FunId, ClassId, Class};
 use crate::alloc::Alloc;
 use crate::object::Object;
+use crate::closure::Closure;
 use crate::array::Array;
 use crate::bytearray::ByteArray;
 use crate::codegen::CompiledFun;
@@ -173,15 +174,6 @@ pub enum Insn
     ret,
 }
 
-#[derive(Clone)]
-pub struct Closure
-{
-    pub fun_id: FunId,
-
-    // Captured variable slots
-    pub slots: Vec<Value>,
-}
-
 #[derive(Clone, Default)]
 pub struct Dict
 {
@@ -341,6 +333,14 @@ impl Value
         }
     }
 
+    pub fn unwrap_clos(&mut self) -> &mut Closure
+    {
+        match self {
+            Value::Closure(p) => unsafe { &mut **p },
+            _ => panic!("expected closure value but got {:?}", self)
+        }
+    }
+
     pub fn unwrap_arr(&mut self) -> &mut Array
     {
         match self {
@@ -1680,9 +1680,8 @@ impl Actor
                         &mut [],
                     );
 
-                    let clos = Closure { fun_id, slots: vec![Undef; num_slots] };
-                    let clos_val = self.alloc.alloc(clos).unwrap();
-                    push!(Value::Closure(clos_val));
+                    let clos = Closure::new(fun_id, num_slots, &mut self.alloc).unwrap();
+                    push!(clos);
                 }
 
                 // Set a closure slot
@@ -1693,7 +1692,7 @@ impl Actor
                     match clos {
                         Value::Closure(clos) => {
                             let clos = unsafe { &mut *clos };
-                            clos.slots[idx as usize] = val;
+                            clos.set(idx as usize, val);
                         }
                         _ => error!("clos_set", "expected closure")
                     }
@@ -1706,7 +1705,7 @@ impl Actor
                     let val = match fun {
                         Value::Closure(clos) => {
                             let clos = unsafe { &**clos };
-                            clos.slots[idx as usize]
+                            clos.get(idx as usize)
                         }
                         _ => error!("clos_get", "not a closure")
                     };