Added parser tracing

Cargo.toml

@@ -8,6 +8,9 @@ edition = "2021"
 [dependencies]
 colored = "2.0.4"
 lazy_static = "1.4.0"
+tracing = "0.1.40"
+tracing-attributes = { version = "0.1.27", features = [] }
+tracing-subscriber = "0.3.18"
 
 [features]
 disassemble = []

src/compiler/compiler.rs

@@ -19,7 +19,10 @@ impl Compiler {
         return if parser.had_error {
             None
         } else {
-            parser.blocks.pop()
+            let block = parser.blocks.pop();
+            #[cfg(feature = "disassemble")]
+            block.as_ref()?.disassemble_block();
+            block
         };
     }
 }

src/compiler/mod.rs

@@ -14,13 +14,15 @@ struct Token {
     line: u32,
 }
 
+#[derive(Debug)]
 struct Scanner {
     source: Vec<char>,
     start: usize,
     current: usize,
     line: u32,
 }
 
+#[derive(Debug)]
 struct Parser {
     scanner: Scanner,
     blocks: Vec<Block>,
@@ -30,6 +32,7 @@ struct Parser {
     panic_mode: bool,
 }
 
+#[derive(Debug)]
 pub(crate) struct Compiler {
     parser: Option<Parser>,
 }

src/compiler/parser/mod.rs

@@ -4,6 +4,7 @@ use crate::compiler::{Parser, Scanner, Token};
 use crate::vm::opcodes::OpCode;
 use crate::vm::{Block, Value};
 use rules::{ParseRule, Precedence};
+use tracing_attributes::instrument;
 
 mod rules;
 
@@ -19,6 +20,7 @@ impl Parser {
         }
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     pub(in crate::compiler) fn advance(&mut self) {
         std::mem::swap(&mut self.previous_token, &mut self.current_token);
         loop {
@@ -30,10 +32,12 @@ impl Parser {
         }
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     pub(in crate::compiler) fn expression(&mut self) {
         self.parse_precedence(Precedence::Assignment);
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self, precedence)))]
     fn parse_precedence(&mut self, precedence: Precedence) {
         self.advance();
         let prefix_rule = self.get_rule(self.previous_token.token_type.clone()).prefix;
@@ -54,16 +58,19 @@ impl Parser {
         }
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     fn number(&mut self) {
         let value = self.previous_token.token.parse::<f64>().unwrap();
         self.emit_constant(value);
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     fn grouping(&mut self) {
         self.expression();
         self.consume(TokenType::RightParen, "Expect end of expression");
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     fn binary(&mut self) {
         let operator_type = self.previous_token.token_type.clone();
         let rule = self.get_rule(operator_type.clone());
@@ -78,6 +85,7 @@ impl Parser {
         }
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     fn unary(&mut self) {
         let operator_type = self.previous_token.token_type.clone();
 

src/main.rs

@@ -13,6 +13,9 @@ use crate::vm::VirtualMachine;
 fn main() {
     print_tagline();
 
+    #[cfg(feature = "disassemble")]
+    setup_tracing();
+
     let args: Vec<String> = env::args().collect();
     if args.len() == 1 {
         run_repl();
@@ -23,6 +26,16 @@ fn main() {
     }
 }
 
+#[cfg(feature = "disassemble")]
+fn setup_tracing() {
+    tracing_subscriber::fmt()
+        .with_span_events(
+            tracing_subscriber::fmt::format::FmtSpan::ENTER
+                | tracing_subscriber::fmt::format::FmtSpan::CLOSE,
+        )
+        .init()
+}
+
 fn print_tagline() {
     println!(
         "Hi, this is {} - a toy language you didn't wait for.",

src/vm/block/disassembler.rs

@@ -4,7 +4,7 @@ use crate::vm::Block;
 #[cfg(feature = "disassemble")]
 impl Block {
     #[allow(dead_code)]
-    pub(in crate::vm) fn disassemble_block(&self) {
+    pub(crate) fn disassemble_block(&self) {
         println!();
         println!("=== <{}>  ===", self.name);
 

src/vm/mod.rs

@@ -16,17 +16,20 @@ pub struct VirtualMachine {
     stack: Vec<Value>,
 }
 
+#[derive(Debug)]
 pub(crate) struct Block {
     name: String,
     constants: Constants,
     instructions: Vec<u8>,
     lines: Vec<Line>,
 }
 
+#[derive(Debug)]
 struct Constants {
     values: Vec<Value>,
 }
 
+#[derive(Debug)]
 struct Line {
     pub line: usize,
     pub offset: usize,

src/vm/virtual_machine.rs

@@ -11,6 +11,8 @@ impl VirtualMachine {
     }
 
     pub fn interpret(&mut self, source: String) -> Result {
+        self.reset();
+
         let mut compiler = Compiler::new();
         let block = compiler.compile(source);
         return if let Some(block) = block {
@@ -20,11 +22,16 @@ impl VirtualMachine {
         };
     }
 
+    fn reset(&mut self) {
+        self.ip = 0;
+        self.stack.clear();
+    }
+
     #[inline(always)]
     fn run(&mut self, mut block: Block) -> Result {
         loop {
-            #[cfg(feature = "disassemble")]
-            block.disassemble_instruction(self.ip);
+            // #[cfg(feature = "disassemble")]
+            // block.disassemble_instruction(self.ip);
             match OpCode::from_u8(block.read_u8(self.ip)) {
                 OpCode::Return => {
                     let value = self.pop();
@@ -105,8 +112,6 @@ mod tests {
     fn can_create_vm() {
         let vm = super::VirtualMachine::new();
         assert_eq!(0, vm.ip);
-        // assert_eq!(0, vm.block.instructions.len());
-        // assert_eq!(0, vm.block.constants.len());
         assert_eq!(0, vm.stack.len());
     }