expression statement

components/lox-compile/src/compile.rs

@@ -6,10 +6,12 @@ use lox_ir::{
 
 #[salsa::tracked]
 pub fn compile_file(db: &dyn crate::Db, input_file: InputFile) -> Chunk {
-    let exprs = lox_parse::parse_file(db, input_file);
+    let stmts = lox_parse::parse_file(db, input_file);
     let mut chunk = Chunk::default();
-    for expr in exprs {
-        compile_expr(db, expr, &mut chunk);
+    for stmt in stmts {
+        match stmt {
+            syntax::Stmt::Expr(expr) => compile_expr(db, expr, &mut chunk),
+        }
     }
     chunk
 }

components/lox-ir/src/syntax.rs

@@ -59,7 +59,16 @@ impl<'db> salsa::DebugWithDb<dyn crate::Db + 'db> for Expr {
 }
 
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Stmt {
     // expression statement, like `1 + 2;`
     Expr(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(),
+        }
+    }
 }

components/lox-parse/src/file_parser.rs

@@ -1,10 +1,10 @@
 use crate::parser::Parser;
 
-use lox_ir::{input_file::InputFile, syntax::Expr};
+use lox_ir::{input_file::InputFile, syntax::Stmt};
 
 #[salsa::tracked(return_ref)]
-pub fn parse_file(db: &dyn crate::Db, input_file: InputFile) -> Vec<Expr> {
+pub fn parse_file(db: &dyn crate::Db, input_file: InputFile) -> Vec<Stmt> {
     let token_tree = lox_lex::lex_file(db, input_file);
     let mut parser = Parser::new(db, token_tree);
-    parser.parse_exprs()
+    parser.parse()
 }

components/lox-parse/src/parser.rs

@@ -29,24 +29,24 @@ impl<'me> Parser<'me> {
         }
     }
 
-    pub(crate) fn parse_exprs(&mut self) -> Vec<Expr> {
-        let mut exprs = vec![];
-        while let Some(expr) = self.parse_expr() {
-            exprs.push(expr);
+    pub(crate) fn parse(&mut self) -> Vec<Stmt> {
+        let mut stmts = vec![];
+        while let Some(stmt) = self.expr_stmt() {
+            stmts.push(stmt);
         }
         if self.tokens.peek().is_some() {
             let span = self.tokens.peek_span();
-            self.error(span, "extra tokens after expression")
+            self.error(span, "extra tokens after statement")
                 .emit(self.db);
         }
-        exprs
+        stmts
     }
 
-    // fn expr_stmt(&mut self) -> Option<Stmt> {
-    //     let expr = self.parse_expr()?;
-    //     self.eat(Token::Semicolon);
-    //     Some(Stmt::Expr(expr))
-    // }
+    fn expr_stmt(&mut self) -> Option<Stmt> {
+        let expr = self.parse_expr()?;
+        self.eat(Token::Semicolon);
+        Some(Stmt::Expr(expr))
+    }
 
     // expression     → equality ;
     // equality       → comparison ( ( "!=" | "==" ) comparison )* ;

lox_tests/arithmetic.syntax

@@ -1,35 +1,43 @@
-BinaryOp {
-    left: NumberLiteral(1),
-    op: Plus,
-    right: NumberLiteral(2),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Plus,
+        right: NumberLiteral(2),
+    },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: Plus,
-    right: BinaryOp {
-        left: NumberLiteral(2),
-        op: Star,
-        right: NumberLiteral(3),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Plus,
+        right: BinaryOp {
+            left: NumberLiteral(2),
+            op: Star,
+            right: NumberLiteral(3),
+        },
     },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: Minus,
-    right: BinaryOp {
-        left: NumberLiteral(2),
-        op: Slash,
-        right: NumberLiteral(3),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Minus,
+        right: BinaryOp {
+            left: NumberLiteral(2),
+            op: Slash,
+            right: NumberLiteral(3),
+        },
     },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: Plus,
-    right: BinaryOp {
-        left: NumberLiteral(2),
-        op: Star,
-        right: UnaryOp {
-            op: Minus,
-            expr: NumberLiteral(3),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Plus,
+        right: BinaryOp {
+            left: NumberLiteral(2),
+            op: Star,
+            right: UnaryOp {
+                op: Minus,
+                expr: NumberLiteral(3),
+            },
         },
     },
 }

lox_tests/boolean.syntax

@@ -1,10 +1,18 @@
-BooleanLiteral(true)
-BooleanLiteral(false)
-UnaryOp {
-    op: Bang,
+Expr {
     expr: BooleanLiteral(true),
 }
-UnaryOp {
-    op: Bang,
+Expr {
     expr: BooleanLiteral(false),
 }
+Expr {
+    expr: UnaryOp {
+        op: Bang,
+        expr: BooleanLiteral(true),
+    },
+}
+Expr {
+    expr: UnaryOp {
+        op: Bang,
+        expr: BooleanLiteral(false),
+    },
+}

lox_tests/comparison.syntax

@@ -1,20 +1,28 @@
-BinaryOp {
-    left: NumberLiteral(1),
-    op: Less,
-    right: NumberLiteral(2),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Less,
+        right: NumberLiteral(2),
+    },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: LessEqual,
-    right: NumberLiteral(1),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: LessEqual,
+        right: NumberLiteral(1),
+    },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: Greater,
-    right: NumberLiteral(2),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: Greater,
+        right: NumberLiteral(2),
+    },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: GreaterEqual,
-    right: NumberLiteral(1),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: GreaterEqual,
+        right: NumberLiteral(1),
+    },
 }

lox_tests/equality.syntax

@@ -1,10 +1,14 @@
-BinaryOp {
-    left: NumberLiteral(1),
-    op: EqualEqual,
-    right: NumberLiteral(2),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: EqualEqual,
+        right: NumberLiteral(2),
+    },
 }
-BinaryOp {
-    left: NumberLiteral(1),
-    op: NotEqual,
-    right: NumberLiteral(2),
+Expr {
+    expr: BinaryOp {
+        left: NumberLiteral(1),
+        op: NotEqual,
+        right: NumberLiteral(2),
+    },
 }

lox_tests/string.syntax

@@ -1,17 +1,7 @@
-BinaryOp {
-    left: StringLiteral(hello),
-    op: Plus,
-    right: StringLiteral( world),
-}
-Diagnostic {
-    severity: Error,
-    span: @14..@15,
-    message: "extra tokens after expression",
-    labels: [
-        Label {
-            span: @14..@15,
-            message: "here",
-        },
-    ],
-    children: [],
+Expr {
+    expr: BinaryOp {
+        left: StringLiteral(hello),
+        op: Plus,
+        right: StringLiteral( world),
+    },
 }