add feature debug_print_code and remove unwanted functions

Cargo.toml

@@ -9,5 +9,6 @@ lazy_static = "1.4.0"
 byteorder = "1.4.3"
 
 [features]
+debug_print_code = []
 debug_trace_execution = []
 # default = ["debug_trace_execution"]

src/code/definitions.rs

@@ -163,6 +163,18 @@ impl Instructions {
         }
     }
 
+    // Disassemble instructions after compilation
+    #[allow(dead_code)]
+    pub fn disassemble(&self) {
+        println!(
+            "--------- Instructions [len: {:<4} --------------------",
+            self.len(),
+        );
+        print!("{}", self);
+        println!("------------------------------------------------------");
+    }
+
+    // Print current instructions during execution
     #[allow(dead_code)]
     pub fn print(&self, ip: usize) {
         println!(

src/common/builtins.rs

@@ -139,7 +139,7 @@ fn builtin_str(args: Vec<Rc<Object>>) -> Result<Rc<Object>, String> {
 }
 
 fn builtin_time(args: Vec<Rc<Object>>) -> Result<Rc<Object>, String> {
-    if args.len() != 0 {
+    if !args.is_empty() {
         return Err(String::from("'time' takes no argument(s)"));
     }
     let current_time = SystemTime::now();

src/compiler/mod.rs

@@ -105,12 +105,43 @@ impl Compiler {
     }
 
     pub fn bytecode(&self) -> Bytecode {
+        let instructions = self.get_curr_instructions();
+        let constants = self.constants.clone();
+        #[cfg(feature = "debug_print_code")]
+        {
+            instructions.disassemble();
+            self.print_constants();
+        }
         Bytecode {
-            instructions: self.get_curr_instructions(),
-            constants: self.constants.clone(),
+            instructions,
+            constants,
         }
     }
 
+    #[allow(dead_code)]
+    fn print_constants(&self) {
+        let constants = self.constants.clone();
+        println!(
+            "----------- Constants [len: {:<4} ---------------------",
+            constants.len(),
+        );
+
+        for (i, obj) in constants.iter().enumerate() {
+            println!("[{}] {}", i, obj);
+            match obj {
+                Object::Clos(cl) => {
+                    let closure = cl.clone();
+                    closure.func.instructions.disassemble();
+                }
+                Object::CompiledFunc(func) => {
+                    func.instructions.disassemble();
+                }
+                _ => {}
+            }
+        }
+        println!("------------------------------------------------------");
+    }
+
     // Helper to add a constant to the constants pool
     pub fn add_constant(&mut self, obj: Object) -> usize {
         self.constants.push(obj);
@@ -217,28 +248,15 @@ impl Compiler {
     }
 
     fn compile_block_statement(&mut self, stmt: BlockStatement) -> Result<(), CompileError> {
-        self.compile_statements_nounwrap(stmt.statements)
+        for stmt in stmt.statements {
+            self.compile_statement(stmt)?;
+        }
+        Ok(())
     }
 
     fn compile_statements(&mut self, statements: Vec<Statement>) -> Result<(), CompileError> {
-        self.compile_statements_nounwrap(statements)
-        // if let Object::Return(retval) = result {
-        //     return Ok(*retval);
-        // }
-        // Ok(result)
-    }
-
-    fn compile_statements_nounwrap(
-        &mut self,
-        statements: Vec<Statement>,
-    ) -> Result<(), CompileError> {
-        // let mut result = Object::Nil;
         for stmt in statements {
-            // let result =
             self.compile_statement(stmt)?;
-            // if let Object::Return(_) = result {
-            //     return Ok(result);
-            // }
         }
         Ok(())
     }