From db84365c27b36fc20768f193e8c1a3d5e678d557 Mon Sep 17 00:00:00 2001
From: _ <_@_>
Date: Sun, 1 Oct 2023 20:31:30 -0500
Subject: [PATCH] :recycle: refactor: State owns its Chunk now

---
 lunar_wave_cli/src/main.rs       |   2 +-
 lunar_wave_vm/src/loader.rs      |   8 +-
 lunar_wave_vm/src/state.rs       | 229 +++++++++++++++----------------
 lunar_wave_vm/src/tests.rs       |  44 +++---
 lunar_wave_vm/tests/embedding.rs |   2 +-
 5 files changed, 138 insertions(+), 147 deletions(-)

diff --git a/lunar_wave_cli/src/main.rs b/lunar_wave_cli/src/main.rs
index e983175..d4c61e3 100644
--- a/lunar_wave_cli/src/main.rs
+++ b/lunar_wave_cli/src/main.rs
@@ -51,7 +51,7 @@ fn main () -> Result <(), lwvm::StepError> {
 	
 	let upvalues = lwvm::State::upvalues_from_args ([exe_name].into_iter ().chain (args));
 	
-	let mut vm = lwvm::State::new (&chunk, &upvalues);
+	let mut vm = lwvm::State::new (chunk, upvalues);
 	if std::env::var("LWVM_DEBUG").is_ok() {
 		vm.debug_print = true;
 	}
diff --git a/lunar_wave_vm/src/loader.rs b/lunar_wave_vm/src/loader.rs
index 16a63fc..0d31daa 100644
--- a/lunar_wave_vm/src/loader.rs
+++ b/lunar_wave_vm/src/loader.rs
@@ -9,11 +9,9 @@ use crate::{
 };
 
 pub fn compile_bytecode_from_file (path: &str) -> Vec <u8> {
-	use std::{
-		process::{
-			Command,
-			Stdio,
-		},
+	use std::process::{
+		Command,
+		Stdio,
 	};
 	
 	let child = Command::new ("luac5.4")
diff --git a/lunar_wave_vm/src/state.rs b/lunar_wave_vm/src/state.rs
index a551221..2e33800 100644
--- a/lunar_wave_vm/src/state.rs
+++ b/lunar_wave_vm/src/state.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-
 use crate::{
 	instruction::Instruction,
 	value::{
@@ -8,21 +6,21 @@ use crate::{
 	},
 };
 
-#[derive (Debug)]
+#[derive (Clone, Debug)]
 pub struct Upvalue {
 	pub in_stack: bool,
 	pub idx: u8,
 	pub kind: u8,
 }
 
-#[derive (Debug)]
+#[derive (Clone, Debug)]
 pub struct Block {
 	pub instructions: Vec <Instruction>,
 	pub constants: Vec <Value>,
 	pub upvalues: Vec <Upvalue>,
 }
 
-#[derive (Debug)]
+#[derive (Clone, Debug)]
 pub struct Chunk {
 	pub blocks: Vec <Block>,
 }
@@ -47,7 +45,7 @@ pub struct Breakpoint {
 }
 
 #[derive (Debug)]
-pub struct State <'a> {
+pub struct State {
 	pub registers: Vec <Value>,
 	// Currently only used for native function calls
 	top: usize,
@@ -55,8 +53,8 @@ pub struct State <'a> {
 	
 	pub debug_print: bool,
 	step_count: u32,
-	chunk: &'a Chunk,
-	upvalues: &'a [Value],
+	chunk: Chunk,
+	upvalues: Vec <Value>,
 }
 
 fn lw_io_write (l: &mut State, num_args: usize) -> usize {
@@ -142,8 +140,8 @@ pub struct StepError {
 	msg: &'static str,
 }
 
-impl <'a> State <'a> {
-	pub fn new (chunk: &'a Chunk, upvalues: &'a [Value]) -> Self {
+impl State {
+	pub fn new (chunk: Chunk, upvalues: Vec <Value>) -> Self {
 		Self {
 			// TODO: Stack is actually supposed to grow to a limit of
 			// idk 10,000. I thought it was fixed at 256.
@@ -232,11 +230,10 @@ impl <'a> State <'a> {
 	
 	pub fn step (&mut self) -> Result <Option <StepOutput>, StepError> 
 	{
-		let chunk = self.chunk;
 		self.step_count += 1;
 		
 		let frame = self.stack.last_mut ().unwrap ().clone ();
-		let block = chunk.blocks.get (frame.block_idx).unwrap ();
+		let block = self.chunk.blocks.get (frame.block_idx).unwrap ();
 		
 		let mut next_pc = frame.program_counter;
 		
@@ -256,10 +253,10 @@ impl <'a> State <'a> {
 			self.make_step_error (msg, instruction)
 		};
 		
-		match instruction {
+		match instruction.clone () {
 			Instruction::Add (a, b, c) => {
-				let v_b = self.reg (*b);
-				let v_c = self.reg (*c);
+				let v_b = self.reg (b);
+				let v_c = self.reg (c);
 				
 				let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ()) 
 				{
@@ -271,24 +268,24 @@ impl <'a> State <'a> {
 					Value::from (v_b + v_c)
 				};
 				
-				*self.reg_mut (*a) = x;
+				*self.reg_mut (a) = x;
 			},
 			Instruction::AddI (a, b, s_c) => {
-				let v_b = self.reg (*b);
+				let v_b = self.reg (b);
 				
 				let x = if let Some (v_b) = v_b.as_int () 
 				{
-					Value::from (v_b + *s_c as i64)
+					Value::from (v_b + s_c as i64)
 				}
 				else {
 					let v_b = v_b.as_float ().unwrap_or_else (|| panic! ("{v_b}"));
-					Value::from (v_b + f64::from (*s_c))
+					Value::from (v_b + f64::from (s_c))
 				};
 				
-				*self.reg_mut (*a) = x;
+				*self.reg_mut (a) = x;
 			},
 			Instruction::Call (a, b, c) => {
-				let b = usize::from (*b);
+				let b = usize::from (b);
 				
 				// Take arguments from registers [a + 1, a + b)
 				// Call the function in register [a]
@@ -301,7 +298,7 @@ impl <'a> State <'a> {
 				// Do a clone here to avoid a borow problem.
 				// Should be fixable with more clever code.
 				
-				let v_a = self.reg (*a).clone ();
+				let v_a = self.reg (a).clone ();
 				
 				match v_a {
 					Value::BogusClosure (rc) => {
@@ -315,7 +312,7 @@ impl <'a> State <'a> {
 						self.stack.push (StackFrame {
 							program_counter: 0,
 							block_idx: target_block,
-							register_offset: current_frame.register_offset + *a as usize + 1,
+							register_offset: current_frame.register_offset + a as usize + 1,
 						});
 						
 						if self.debug_print {
@@ -329,7 +326,7 @@ impl <'a> State <'a> {
 					},
 					Value::RsFunc (x) => {
 						let current_frame = self.stack.last ().unwrap ();
-						let new_offset = current_frame.register_offset + usize::from (*a) + 1;
+						let new_offset = current_frame.register_offset + usize::from (a) + 1;
 						
 						// Trash the stack frame so it doesn't point to a
 						// valid Lua function
@@ -340,7 +337,7 @@ impl <'a> State <'a> {
 						});
 						
 						let num_args = if b == 0 {
-							self.top - *a as usize
+							self.top - a as usize
 						}
 						else {
 							b - 1
@@ -357,7 +354,7 @@ impl <'a> State <'a> {
 						}
 						
 						// Set up top for the next call
-						if *c == 0 {
+						if c == 0 {
 							self.top = popped_frame.register_offset - 1 + num_results;
 						}
 					},
@@ -367,10 +364,10 @@ impl <'a> State <'a> {
 				}
 			},
 			Instruction::Closure (a, b) => {
-				let b = usize::try_from (*b).unwrap ();
+				let b = usize::try_from (b).unwrap ();
 				
 				let idx = frame.block_idx + b + 1;
-				let block = &chunk.blocks [idx];
+				let block = &self.chunk.blocks [idx];
 				
 				let mut new_upvalues = Vec::with_capacity (block.upvalues.len ());
 				for uv in &block.upvalues {
@@ -384,31 +381,31 @@ impl <'a> State <'a> {
 					new_upvalues.push (val);
 				}
 				
-				*self.reg_mut (*a) = Value::from (BogusClosure {
+				*self.reg_mut (a) = Value::from (BogusClosure {
 					idx,
 					upvalues: new_upvalues,
 				});
 			},
 			Instruction::Div (a, b, c) => {
-				let v_b = self.reg (*b);
-				let v_c = self.reg (*c);
+				let v_b = self.reg (b);
+				let v_c = self.reg (c);
 				
 				let v_b = v_b.as_float ().unwrap_or_else (|| panic! ("{v_b}"));
 				
 				let v_c = v_c.as_float ().ok_or_else (|| make_step_error ("C must be a number"))?;
 				
-				*self.reg_mut (*a) = Value::from (v_b / v_c);
+				*self.reg_mut (a) = Value::from (v_b / v_c);
 			},
 			Instruction::EqI (a, sb, k_flag) => {
-				if (self.reg (*a).as_int ().unwrap () == *sb as i64) != *k_flag 
+				if (self.reg (a).as_int ().unwrap () == sb as i64) != k_flag 
 				{
 					next_pc += 1;
 				}
 			},
 			Instruction::EqK (a, b, k_flag) => {
-				let b = usize::from (*b);
+				let b = usize::from (b);
 				
-				if (*self.reg (*a) == k [b]) != *k_flag {
+				if (*self.reg (a) == k [b]) != k_flag {
 					next_pc += 1;
 				}
 			},
@@ -416,60 +413,60 @@ impl <'a> State <'a> {
 				// This is used for NewTable. Maybe it's for reserving
 				// capacity in the array or something?
 				
-				assert_eq! (*ax, 0, "implemented only for ax == 0");
+				assert_eq! (ax, 0, "implemented only for ax == 0");
 			},
 			Instruction::ForLoop (a, bx) => {
-				let mut iter = self.reg (*a + 3).as_int ().unwrap ();
+				let mut iter = self.reg (a + 3).as_int ().unwrap ();
 				iter += 1;
-				*self.reg_mut (*a + 3) = iter.into ();
+				*self.reg_mut (a + 3) = iter.into ();
 				
-				let stop = self.reg (*a + 1).as_int ().unwrap ();
+				let stop = self.reg (a + 1).as_int ().unwrap ();
 				
 				if iter <= stop {
-					next_pc -= i32::try_from (*bx).unwrap ();
+					next_pc -= i32::try_from (bx).unwrap ();
 				}
 			},
 			Instruction::ForPrep (a, bx) => {
-				let start = self.reg (*a).as_int ().unwrap ();
-				let stop = self.reg (*a + 1).as_int ().unwrap ();
+				let start = self.reg (a).as_int ().unwrap ();
+				let stop = self.reg (a + 1).as_int ().unwrap ();
 				
 				if start > stop {
-					next_pc += i32::try_from (*bx).unwrap () + 1;
+					next_pc += i32::try_from (bx).unwrap () + 1;
 				}
 				
-				*self.reg_mut (*a + 3) = start.into ();
+				*self.reg_mut (a + 3) = start.into ();
 			},
 			Instruction::GetField (a, b, c) => {
-				let t = match self.reg (*b) {
+				let t = match self.reg (b) {
 					Value::Nil => Err (make_step_error ("R[B] must not be nil"))?,
 					Value::Table (t) => t,
 					_ => Err (make_step_error ("R[B] must be a table"))?,
 				};
 				
-				let key = match &k [usize::from (*c)] {
+				let key = match &k [usize::from (c)] {
 					Value::String (s) => s,
 					_ => panic! ("K[C] must be a string"),
 				};
 				
 				let val = t.borrow ().get_str (key.as_str ()).clone ();
 				
-				*self.reg_mut (*a) = val;
+				*self.reg_mut (a) = val;
 			},
 			Instruction::GetTable (a, b, c) => {
-				let t = match self.reg (*b) {
+				let t = match self.reg (b) {
 					Value::Table (t) => t,
 					_ => panic! ("R[B] must be a table"),
 				};
 				
-				let key = self.reg (*c);
+				let key = self.reg (c);
 				
 				let val = t.borrow ().get (key.clone ());
 				
-				*self.reg_mut (*a) = val;
+				*self.reg_mut (a) = val;
 			},
 			Instruction::GetTabUp (a, b, c) => {
-				let b = usize::try_from (*b).unwrap ();
-				let c = usize::try_from (*c).unwrap ();
+				let b = usize::try_from (b).unwrap ();
+				let c = usize::try_from (c).unwrap ();
 				
 				// If we're inside a closure, use its upvalues
 				// instead of the chunk's upvalues
@@ -495,17 +492,17 @@ impl <'a> State <'a> {
 					_ => panic! ("GetTabUp only supports string keys"),
 				};
 				
-				*self.reg_mut (*a) = table.get (key);
+				*self.reg_mut (a) = table.get (key);
 			},
 			Instruction::GetI (a, b, c) => {
-				let key = i64::try_from (*c).unwrap ();
+				let key = i64::try_from (c).unwrap ();
 				
 				let value = {
-					let table = self.reg (*b).as_table ().expect ("GetI only works on tables").borrow ();
+					let table = self.reg (b).as_table ().expect ("GetI only works on tables").borrow ();
 					table.get_int (key)
 				};
 				
-				*self.reg_mut (*a) = value;
+				*self.reg_mut (a) = value;
 			},
 			Instruction::GetUpVal (a, b) => {
 				let this_func = self.stack.last ().unwrap ().register_offset - 1;
@@ -514,20 +511,20 @@ impl <'a> State <'a> {
 					_ => panic! ("Can't do GetUpVal outside a closure"),
 				};
 				
-				let b  = usize::try_from  (*b).unwrap ();
+				let b  = usize::try_from  (b).unwrap ();
 				
 				let upvalue = match closure.borrow ().upvalues.get (b) {
 					Some (x) => x.clone (),
 					None => {
-						dbg! (chunk, &self);
+						dbg! (&self);
 						panic! ("Missing upvalue");
 					}
 				};
-				*self.reg_mut (*a) = upvalue;
+				*self.reg_mut (a) = upvalue;
 			},
 			Instruction::Jmp (s_j) => next_pc += s_j,
 			Instruction::Len (a, b) => {
-				let len = match self.reg (*b) {
+				let len = match self.reg (b) {
 					Value::BogusClosure (_) => Err (make_step_error ("attempt to get length of a function value"))?,
 					Value::Boolean (_) => Err (make_step_error ("attempt to get length of a boolean value"))?,
 					Value::Float (_) => Err (make_step_error ("attempt to get length of a number value"))?,
@@ -538,31 +535,31 @@ impl <'a> State <'a> {
 					Value::Table (t) => t.borrow ().length ().into (),
 				};
 				
-				*self.reg_mut (*a) = len;
+				*self.reg_mut (a) = len;
 			}
 			Instruction::LoadF (a, sbx) => {
-				*self.reg_mut (*a) = Value::Float (*sbx as f64);
+				*self.reg_mut (a) = Value::Float (sbx as f64);
 			}
 			Instruction::LoadFalse (a) => {
-				*self.reg_mut (*a) = false.into ();
+				*self.reg_mut (a) = false.into ();
 			},
 			Instruction::LoadI (a, sbx) => {
-				*self.reg_mut (*a) = Value::Integer (*sbx as i64);
+				*self.reg_mut (a) = Value::Integer (sbx as i64);
 			},
 			Instruction::LoadK (a, bx) => {
-				let bx = usize::try_from (*bx).unwrap ();
+				let bx = usize::try_from (bx).unwrap ();
 				
-				*self.reg_mut (*a) = k [bx].clone ();
+				*self.reg_mut (a) = k [bx].clone ();
 			},
 			Instruction::LoadNil (a) => {
-				*self.reg_mut (*a) = Value::Nil;
+				*self.reg_mut (a) = Value::Nil;
 			},
 			Instruction::LoadTrue (a) => {
-				*self.reg_mut (*a) = true.into ();
+				*self.reg_mut (a) = true.into ();
 			},
 			Instruction::MmBin (a, b, _c) => {
-				let a = self.reg (*a);
-				let b = self.reg (*b);
+				let a = self.reg (a);
+				let b = self.reg (b);
 				
 				if a.as_float().is_some() && b.as_float().is_some () {
 					// No need for metamethods
@@ -578,20 +575,20 @@ impl <'a> State <'a> {
 				// Ignore
 			},
 			Instruction::ModK (a, b, c) => {
-				let b = self.reg (*b).as_int().unwrap ();
-				let c = k [usize::from (*c)].as_int ().unwrap ();
+				let b = self.reg (b).as_int().unwrap ();
+				let c = k [usize::from (c)].as_int ().unwrap ();
 				
-				*self.reg_mut (*a) = (b % c).into ();
+				*self.reg_mut (a) = (b % c).into ();
 			},
 			Instruction::Move (a, b) => {
 				// If the value in b is deleted instead of duplicated,
 				// a bunch of tests fail
 				
-				*self.reg_mut (*a) = self.reg (*b).clone ();
+				*self.reg_mut (a) = self.reg (b).clone ();
 			},
 			Instruction::Mul (a, b, c) => {
-				let v_b = self.reg (*b);
-				let v_c = self.reg (*c);
+				let v_b = self.reg (b);
+				let v_c = self.reg (c);
 				
 				let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ()) 
 				{
@@ -603,11 +600,11 @@ impl <'a> State <'a> {
 					Value::from (v_b * v_c)
 				};
 				
-				*self.reg_mut (*a) = x;
+				*self.reg_mut (a) = x;
 			},
 			Instruction::MulK (a, b, c) => {
-				let v_b = self.reg (*b);
-				let v_c = &k [usize::from (*c)];
+				let v_b = self.reg (b);
+				let v_c = &k [usize::from (c)];
 				
 				let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ()) 
 				{
@@ -619,30 +616,30 @@ impl <'a> State <'a> {
 					Value::from (v_b * v_c)
 				};
 				
-				*self.reg_mut (*a) = x;
+				*self.reg_mut (a) = x;
 			},
 			Instruction::NewTable (a) => {
-				*self.reg_mut (*a) = Value::Table (Default::default ());
+				*self.reg_mut (a) = Value::Table (Default::default ());
 			},
 			Instruction::Not (a, b) => {
-				*self.reg_mut (*a) = Value::Boolean (! self.reg (*b).is_truthy());
+				*self.reg_mut (a) = Value::Boolean (! self.reg (b).is_truthy());
 			}
-			Instruction::Return (a, b, _c, k) => {
-				let a = usize::try_from (*a).unwrap ();
-				let b = usize::try_from (*b).unwrap ();
+			Instruction::Return (a, b, _c, k_flag) => {
+				let a = usize::try_from (a).unwrap ();
+				let b = usize::try_from (b).unwrap ();
 				
 				let popped_frame = self.stack.pop ().unwrap ();
 				
 				// Build closure if needed. No point building if we're
 				// popping the last frame and exiting the program.
 				
-				if *k && ! self.stack.is_empty () {
+				if k_flag && ! self.stack.is_empty () {
 					let closure_idx = match &self.registers [popped_frame.register_offset + a] {
 						Value::BogusClosure (rc) => rc.borrow ().idx,
 						_ => panic! ("Impossible"),
 					};
 					
-					let upvalue_count = chunk.blocks [closure_idx].upvalues.len ();
+					let upvalue_count = self.chunk.blocks [closure_idx].upvalues.len ();
 					
 					let start_reg = a + popped_frame.register_offset - upvalue_count;
 					
@@ -690,7 +687,7 @@ impl <'a> State <'a> {
 				self.top = popped_frame.register_offset - 1 + 0;
 			},
 			Instruction::Return1 (a) => {
-				let a = usize::try_from (*a).unwrap ();
+				let a = usize::try_from (a).unwrap ();
 				let popped_frame = self.stack.pop ().unwrap ();
 				
 				
@@ -715,58 +712,58 @@ impl <'a> State <'a> {
 				self.top = popped_frame.register_offset - 1 + 1;
 			},
 			Instruction::SetField (a, b, c, k_flag) => {
-				let value = if *k_flag {
-					&k [usize::from (*c)]
+				let value = if k_flag {
+					&k [usize::from (c)]
 				}
 				else {
-					self.reg (*c)
+					self.reg (c)
 				}
 				.clone ();
 				
-				let b = usize::try_from (*b).unwrap ();
+				let b = usize::try_from (b).unwrap ();
 				
 				let key = match k.get (b).unwrap () {
 					Value::String (s) => s.as_ref (),
 					_ => panic! ("SetField only supports string keys"),
 				};
 				
-				let mut dst = self.reg (*a).as_table ()
+				let mut dst = self.reg (a).as_table ()
 				.expect ("SetField only works on tables").borrow_mut ();
 				
 				dst.insert_str (key.as_str (), value);
 			},
 			Instruction::SetI (a, b, c, k_flag) => {
-				let value = if *k_flag {
-					&k [usize::from (*c)]
+				let value = if k_flag {
+					&k [usize::from (c)]
 				}
 				else {
-					self.reg (*c)
+					self.reg (c)
 				}
 				.clone ();
 				
-				let mut dst = self.reg_mut (*a).as_table ().expect ("SetI only works on tables").borrow_mut ();
+				let mut dst = self.reg_mut (a).as_table ().expect ("SetI only works on tables").borrow_mut ();
 				
-				dst.insert_int (i64::from (*b), value);
+				dst.insert_int (i64::from (b), value);
 			},
-			Instruction::SetList (a, b, c, k) => {
-				if *b == 0 {
+			Instruction::SetList (a, b, c, k_flag) => {
+				if b == 0 {
 					panic! ("SetList with b == 0 not implemented");
 				}
-				if *k {
+				if k_flag {
 					panic! ("SetList with k = true not implemented");
 				}
 				
-				let mut dst = self.reg (*a).as_table ().expect ("SetList only works on tables").borrow_mut ();
+				let mut dst = self.reg (a).as_table ().expect ("SetList only works on tables").borrow_mut ();
 				
-				for i in 1..=*b {
-					let src = self.reg (*a + i);
-					dst.insert_int (i64::from (*c + i), src.clone ());
+				for i in 1..=b {
+					let src = self.reg (a + i);
+					dst.insert_int (i64::from (c + i), src.clone ());
 				}
 			},
 			Instruction::SetTabUp (_a, _b, _c) => unimplemented! (),
 			Instruction::Sub (a, b, c) => {
-				let v_b = self.reg (*b);
-				let v_c = self.reg (*c);
+				let v_b = self.reg (b);
+				let v_c = self.reg (c);
 				
 				let x = if let (Some (v_b), Some (v_c)) = (v_b.as_int (), v_c.as_int ()) 
 				{
@@ -778,10 +775,10 @@ impl <'a> State <'a> {
 					Value::from (v_b - v_c)
 				};
 				
-				*self.reg_mut (*a) = x;
+				*self.reg_mut (a) = x;
 			},
 			Instruction::TailCall (a, b, c, k) => {
-				let a = usize::from (*a);
+				let a = usize::from (a);
 				assert! (!k, "closing over values in tail calls not implemented");
 				
 				let offset = frame.register_offset;
@@ -792,7 +789,7 @@ impl <'a> State <'a> {
 						
 						// Shift inputs into place
 						
-						let b = usize::from (*b);
+						let b = usize::from (b);
 						
 						let num_args = if b == 0 {
 							self.top - a
@@ -816,7 +813,7 @@ impl <'a> State <'a> {
 					},
 					Value::RsFunc (x) => {
 						// Shift inputs into place
-						let b = usize::from (*b);
+						let b = usize::from (b);
 						for i in (offset)..(offset + b) {
 							self.registers [i] = self.registers [i + a + 1].take ();
 						}
@@ -847,7 +844,7 @@ impl <'a> State <'a> {
 						}
 						else {
 							// Set up top for the next call
-							if *c == 0 {
+							if c == 0 {
 								self.top = popped_frame.register_offset - 1 + num_results;
 							}
 						}
@@ -858,13 +855,13 @@ impl <'a> State <'a> {
 					},
 				}
 			},
-			Instruction::Test (a, k) => {
-				if self.reg (*a).is_truthy() != *k {
+			Instruction::Test (a, k_flag) => {
+				if self.reg (a).is_truthy() != k_flag {
 					next_pc += 1;
 				}
 			},
 			Instruction::UnM (a, b) => {
-				let v_b = self.reg (*b);
+				let v_b = self.reg (b);
 				
 				let x = if let Some (v_b) = v_b.as_int () 
 				{
@@ -875,7 +872,7 @@ impl <'a> State <'a> {
 					Value::from (-v_b)
 				};
 				
-				*self.reg_mut (*a) = x;
+				*self.reg_mut (a) = x;
 			},
 			Instruction::VarArgPrep (_) => (),
 		}
diff --git a/lunar_wave_vm/src/tests.rs b/lunar_wave_vm/src/tests.rs
index 5e8d17f..03afac3 100644
--- a/lunar_wave_vm/src/tests.rs
+++ b/lunar_wave_vm/src/tests.rs
@@ -22,9 +22,9 @@ fn calculate_hash<T: Hash>(t: &T) -> u64 {
 /// Takes arguments and a parsed Lua chunk, runs its,
 /// and returns the output
 
-fn run_chunk (args: &[&str], chunk: &Chunk) -> Vec <Value> {
+fn run_chunk (args: &[&str], chunk: Chunk) -> Vec <Value> {
 	let upvalues = State::upvalues_from_args (args.into_iter ().map (|s| s.to_string ()));
-	let mut vm = State::new (chunk, &upvalues);
+	let mut vm = State::new (chunk, upvalues);
 	vm.execute_chunk (&[]).unwrap ()
 }
 
@@ -33,7 +33,7 @@ fn run_chunk (args: &[&str], chunk: &Chunk) -> Vec <Value> {
 
 fn run_bytecode (args: &[&str], bc: &[u8]) -> Vec <Value> {
 	let chunk = loader::parse_chunk_from_bytes (&bc).unwrap ();
-	run_chunk (args, &chunk)
+	run_chunk (args, chunk)
 }
 
 /// Takes arguments and Lua source code, 
@@ -119,7 +119,7 @@ fn bools () {
 		let expected: Vec <Value> = expected;
 		
 		let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
-		let mut vm = State::new (&chunk, &upvalues);
+		let mut vm = State::new (chunk.clone (), upvalues);
 		let actual = vm.execute_chunk (&[]).unwrap ();
 		assert_eq! (actual, expected);
 	}
@@ -131,7 +131,7 @@ fn closure () {
 	let bytecode = &crate::loader::compile_bytecode_from_stdin (source.to_vec ());
 	let chunk = crate::loader::parse_chunk_from_bytes (bytecode).unwrap ();
 	
-	assert_eq! (run_chunk (&["_exe_name"], &chunk), vec! [Value::from (23i64)]);
+	assert_eq! (run_chunk (&["_exe_name"], chunk), vec! [Value::from (23i64)]);
 }
 
 #[test]
@@ -175,7 +175,7 @@ fn floats () {
 	] {
 		let expected: Vec <Value> = expected;
 		let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
-		let mut vm = State::new (&chunk, &upvalues);
+		let mut vm = State::new (chunk.clone (), upvalues);
 		let actual = vm.execute_chunk (&[]).unwrap ();
 		
 		assert_eq! (actual, expected);
@@ -191,17 +191,13 @@ fn fma () {
 	
 	assert_eq! (chunk.blocks [3].upvalues.len (), 2);
 	
-	for (arg, expected) in [
-		(vec! ["_exe_name"], vec! [122.into ()]),
-		(vec! ["_exe_name"], vec! [122.into ()]),
-	] {
-		let expected: Vec <Value> = expected;
-		let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
-		let mut vm = State::new (&chunk, &upvalues);
-		let actual = vm.execute_chunk (&[]).unwrap ();
-		
-		assert_eq! (actual, expected);
-	}
+	let arg = vec! ["_exe_name"];
+	let upvalues = State::upvalues_from_args (arg.into_iter ().map (|s| s.to_string ()));
+	let mut vm = State::new (chunk, upvalues);
+	let actual = vm.execute_chunk (&[]).unwrap ();
+	let expected = vec! [Value::from (122)];
+	
+	assert_eq! (actual, expected);
 }
 
 #[test]
@@ -286,22 +282,22 @@ fn is_93 () {
 	
 	let run = run_chunk;
 	
-	assert_eq! (run (&[""], &chunk), vec! [Value::from (1)]);
-	assert_eq! (run (&["", "93"], &chunk), vec! [Value::from (0)]);
-	assert_eq! (run (&["", "94"], &chunk), vec! [Value::from (1)]);
+	assert_eq! (run (&[""], chunk.clone ()), vec! [Value::from (1)]);
+	assert_eq! (run (&["", "93"], chunk.clone ()), vec! [Value::from (0)]);
+	assert_eq! (run (&["", "94"], chunk.clone ()), vec! [Value::from (1)]);
 }
 
 #[test]
 fn native_functions () {
-	fn add (l: &mut State) -> i32 {
+	fn add (_: &mut State) -> i32 {
 		0
 	}
 	
-	fn multiply (l: &mut State) -> i32 {
+	fn multiply (_: &mut State) -> i32 {
 		0
 	}
 	
-	fn greet (l: &mut State) -> i32 {
+	fn greet (_: &mut State) -> i32 {
 		0
 	}
 	
@@ -372,7 +368,7 @@ fn tailcall () {
 	
 	assert_eq! (chunk.blocks [0].instructions [3], Instruction::TailCall (0, 2, 1, false));
 	
-	let actual = run_chunk (&[], &chunk);
+	let actual = run_chunk (&[], chunk);
 	let expected = vec! [Value::from (5)];
 	
 	assert_eq! (actual, expected);
diff --git a/lunar_wave_vm/tests/embedding.rs b/lunar_wave_vm/tests/embedding.rs
index 30ed2b7..5f79aad 100644
--- a/lunar_wave_vm/tests/embedding.rs
+++ b/lunar_wave_vm/tests/embedding.rs
@@ -35,7 +35,7 @@ fn embedding () {
 		Value::from_iter (env.into_iter ()),
 	];
 	
-	let mut vm = State::new (&chunk, &upvalues);
+	let mut vm = State::new (chunk, upvalues);
 	let output = vm.execute_chunk (&vec! []).unwrap ();
 	
 	assert_eq! (output, vec! [Value::from (2019)]);