feat: Add support for return and break statements.

src/ast.rs

@@ -68,15 +68,26 @@ pub enum Statement {
     },
 
     If {
+        kw_span: Span,
         condition: Expression,
         then: Box<Statement>,
         elze: Option<Box<Statement>>,
     },
 
     Loop {
+        kw_span: Span,
         body: Box<Statement>,
     },
 
+    Break {
+        kw_span: Span,
+    },
+
+    Return {
+        kw_span: Span,
+        value: Option<Expression>,
+    },
+
     Compound {
         body: Vec<Statement>,
     },

src/main.rs

@@ -5,7 +5,7 @@ pub mod parser;
 pub mod token;
 
 fn main() {
-    let mut parser = Parser::new("loop {}");
+    let mut parser = Parser::new("break;");
 
     println!("{:#?}", parser.parse_statement());
 }

src/parser.rs

@@ -61,6 +61,8 @@ impl<'src> Parser<'src> {
             TokenKind::KwLet => self.parse_let_statement(),
             TokenKind::KwIf => self.parse_if_statement(),
             TokenKind::KwLoop => self.parse_loop_statement(),
+            TokenKind::KwBreak => self.parse_break_statement(),
+            TokenKind::KwReturn => self.parse_return_statement(),
 
             _ => {
                 let expr = self.parse_expression(0)?;
@@ -70,16 +72,37 @@ impl<'src> Parser<'src> {
         }
     }
 
+    fn parse_return_statement(&mut self) -> ParserResult<Statement> {
+        let kw_span = self.expect(&[TokenKind::KwReturn])?.span;
+
+        let value = if !self.is_peek(TokenKind::Semicolon) {
+            Some(self.parse_expression(0)?)
+        } else {
+            None
+        };
+
+        self.expect(&[TokenKind::Semicolon])?;
+
+        Ok(Statement::Return { kw_span, value })
+    }
+
+    fn parse_break_statement(&mut self) -> ParserResult<Statement> {
+        let kw_span = self.expect(&[TokenKind::KwBreak])?.span;
+        self.expect(&[TokenKind::Semicolon])?;
+
+        Ok(Statement::Break { kw_span })
+    }
+
     fn parse_loop_statement(&mut self) -> ParserResult<Statement> {
-        self.expect(&[TokenKind::KwLoop])?;
+        let kw_span = self.expect(&[TokenKind::KwLoop])?.span;
 
         let body = Box::new(self.parse_compound_statement()?);
 
-        Ok(Statement::Loop { body })
+        Ok(Statement::Loop { body, kw_span })
     }
 
     fn parse_if_statement(&mut self) -> ParserResult<Statement> {
-        self.expect(&[TokenKind::KwIf])?;
+        let kw_span = self.expect(&[TokenKind::KwIf])?.span;
 
         let condition = self.parse_expression(0)?;
         let then = Box::new(self.parse_compound_statement()?);
@@ -99,6 +122,7 @@ impl<'src> Parser<'src> {
             condition,
             then,
             elze,
+            kw_span,
         })
     }