supports print statement

components/lox-compile/src/compile.rs

@@ -11,6 +11,10 @@ pub fn compile_file(db: &dyn crate::Db, input_file: InputFile) -> Chunk {
     for stmt in stmts {
         match stmt {
             syntax::Stmt::Expr(expr) => compile_expr(db, expr, &mut chunk),
+            syntax::Stmt::Print(expr) => {
+                compile_expr(db, expr, &mut chunk);
+                chunk.emit_byte(Code::Print)
+            }
         }
     }
     chunk

components/lox-execute/src/vm.rs

@@ -212,6 +212,11 @@ impl VM {
                 bytecode::Code::String(s) => {
                     self.push(s);
                 }
+                bytecode::Code::Print => {
+                    let value = self.pop();
+                    // FIXME: This should be a call to a intrinsic function.
+                    println!("{:?}", value);
+                },
             }
             if let Some(step_inspect) = &mut step_inspect {
                 step_inspect(instruction, self);

components/lox-ir/src/bytecode.rs

@@ -17,6 +17,7 @@ pub enum Code {
     Less,
     LessEqual,
     String(String),
+    Print
 }
 
 #[derive(PartialEq, Eq, Debug, Clone, Default)]

components/lox-ir/src/kw.rs

@@ -45,4 +45,5 @@ define_keywords! {
     True => "true",
     False => "false",
     Nil => "nil",
+    Print => "print",
 }

components/lox-ir/src/syntax.rs

@@ -63,12 +63,16 @@ impl<'db> salsa::DebugWithDb<dyn crate::Db + 'db> for Expr {
 pub enum Stmt {
     // expression statement, like `1 + 2;`
     Expr(Expr),
+
+    // print statement, like `print 1 + 2;`
+    Print(Expr)
 }
 
 impl salsa::DebugWithDb<dyn crate::Db> for Stmt {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>, db: &dyn crate::Db, _include_all_fields: bool) -> std::fmt::Result {
         match self {
             Stmt::Expr(expr) => f.debug_struct("Expr").field("expr", &expr.debug(db)).finish(),
+            Stmt::Print(expr) => f.debug_struct("Print").field("expr", &expr.debug(db)).finish(),
         }
     }
 }

components/lox-parse/src/parser.rs

@@ -31,7 +31,7 @@ impl<'me> Parser<'me> {
 
     pub(crate) fn parse(&mut self) -> Vec<Stmt> {
         let mut stmts = vec![];
-        while let Some(stmt) = self.expr_stmt() {
+        while let Some(stmt) = self.stmt() {
             stmts.push(stmt);
         }
         if self.tokens.peek().is_some() {
@@ -42,6 +42,19 @@ impl<'me> Parser<'me> {
         stmts
     }
 
+    fn stmt(&mut self) -> Option<Stmt> {
+        if self.eat(Keyword::Print).is_some() {
+            return self.print_stmt();
+        }
+        self.expr_stmt()
+    }
+
+    fn print_stmt(&mut self) -> Option<Stmt> {
+        let expr = self.parse_expr()?;
+        self.eat(Token::Semicolon);
+        Some(Stmt::Print(expr))
+    }
+
     fn expr_stmt(&mut self) -> Option<Stmt> {
         let expr = self.parse_expr()?;
         self.eat(Token::Semicolon);

lox_tests/print.bytecode

@@ -0,0 +1,16 @@
+Chunk {
+    code: [
+        Constant(
+            F64(
+                1.0,
+            ),
+        ),
+        Constant(
+            F64(
+                2.0,
+            ),
+        ),
+        Add,
+        Print,
+    ],
+}

lox_tests/print.execute

@@ -0,0 +1,35 @@
+execute: Constant(
+    F64(
+        1.0,
+    ),
+)
+stack: [
+    Number(
+        1.0,
+    ),
+]
+
+execute: Constant(
+    F64(
+        2.0,
+    ),
+)
+stack: [
+    Number(
+        1.0,
+    ),
+    Number(
+        2.0,
+    ),
+]
+
+execute: Add
+stack: [
+    Number(
+        3.0,
+    ),
+]
+
+execute: Print
+stack: []
+

lox_tests/print.lox

@@ -0,0 +1 @@
+print 1 + 2

lox_tests/print.syntax

@@ -0,0 +1,7 @@
+Print {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Plus,
+        right: NumberLiteral(2),
+    },
+}

lox_tests/print.token

@@ -0,0 +1,12 @@
+TokenTree {
+    source text: "print 1 + 2",
+    tokens: [
+        Alphabetic(print),
+        Whitespace(' '),
+        Number(1),
+        Whitespace(' '),
+        Op(+),
+        Whitespace(' '),
+        Number(2),
+    ],
+}