optimize code execution by not cloning instructions

 - convert instructions into a reference counted object
 - fix disassembly formatting

src/code/definitions.rs

@@ -167,7 +167,7 @@ impl Instructions {
     #[allow(dead_code)]
     pub fn disassemble(&self) {
         println!(
-            "--------- Instructions [len: {:<4} --------------------",
+            "--------- Instructions [len: {:<4}] -------------------",
             self.len(),
         );
         print!("{}", self);

src/common/object.rs

@@ -302,15 +302,15 @@ impl Eq for HMap {}
 // OpReturn is similar to OpReturnValue except that it returns Nil.
 #[derive(Debug, Clone, Default)]
 pub struct CompiledFunction {
-    pub instructions: Instructions,
+    pub instructions: Rc<Instructions>,
     pub num_locals: usize,
     pub num_params: usize,
 }
 
 impl CompiledFunction {
     pub fn new(instructions: Instructions, num_locals: usize, num_params: usize) -> Self {
         Self {
-            instructions,
+            instructions: Rc::new(instructions),
             num_locals,
             num_params,
         }

src/compiler/mod.rs

@@ -122,7 +122,7 @@ impl Compiler {
     fn print_constants(&self) {
         let constants = self.constants.clone();
         println!(
-            "----------- Constants [len: {:<4} ---------------------",
+            "----------- Constants [len: {:<4}] --------------------",
             constants.len(),
         );
 

src/compiler/tests.rs

@@ -92,7 +92,10 @@ fn test_string_object(actual: &Object, expected: &str) {
 #[cfg(test)]
 fn test_function_object(actual_obj: &Object, expected: &CompiledFunction) {
     if let Object::CompiledFunc(actual) = actual_obj {
-        test_instructions(&vec![expected.instructions.clone()], &actual.instructions);
+        test_instructions(
+            &vec![(&*expected.instructions).clone()],
+            &actual.instructions,
+        );
     } else {
         panic!("object is not a compiled function. got={:?}", actual_obj);
     }

src/vm/frame.rs

@@ -15,7 +15,7 @@ impl Frame {
         Frame { closure, ip: 0, bp }
     }
 
-    pub fn instructions(&self) -> &Instructions {
+    pub fn instructions(&self) -> &Rc<Instructions> {
         &self.closure.func.instructions
     }
 }