Fix(parser): Destructure 4-tuple in finalize_prev_slots function recursion.

Author: dylan-sutton-chavez

compiler/src/modules/parser/mod.rs

@@ -267,6 +267,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         }
 
         self.chunk.emit(OpCode::ReturnValue, 0);
+        self.chunk.finalize_prev_slots();
         (self.chunk, self.errors)
     }
 }

compiler/src/modules/parser/types.rs

@@ -131,6 +131,26 @@ impl SSAChunk {
         self.name_index.insert(n.to_string(), i);
         i
     }
+
+    pub fn finalize_prev_slots(&mut self) {
+        let mut ps: Vec<Option<u16>> = vec![None; self.names.len()];
+        for (i, name) in self.names.iter().enumerate() {
+            if let Some(pos) = name.rfind('_') {
+                if let Ok(ver) = name[pos+1..].parse::<u32>() {
+                    if ver > 0 {
+                        let prev = format!("{}_{}", &name[..pos], ver - 1);
+                        if let Some(&j) = self.name_index.get(&prev) {
+                            ps[i] = Some(j);
+                        }
+                    }
+                }
+            }
+        }
+        self.prev_slots = ps;
+        for (_, body, _, _) in &mut self.functions {
+            body.finalize_prev_slots();
+        }
+    }
 }
 
 /*

compiler/src/modules/vm/mod.rs

@@ -235,7 +235,7 @@ impl<'a> VM<'a> {
                     let v = self.pop()?;
                     let slot = op as usize;
                     slots[slot] = Some(v);
-                    if let Some(prev) = prev_slots[slot] { slots[prev] = Some(v); }
+                    if let Some(prev) = prev_slots[slot] { slots[prev as usize] = Some(v); }
 
                     if self.heap.needs_gc() {
                         self.collect(slots); // Garbage collector safepoint; store is the only opcode that grows the heap unboundedly