From 4edcd1a7b73cb3ffb82471a1e42085e01454e30e Mon Sep 17 00:00:00 2001
From: Jooris Hadeler <j.hadeler@outlook.com>
Date: Thu, 15 Jan 2026 21:52:26 +0100
Subject: [PATCH] feat: Add support for `return` and `break` statements.

---
 src/ast.rs    | 11 +++++++++++
 src/main.rs   |  2 +-
 src/parser.rs | 30 +++++++++++++++++++++++++++---
 3 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/src/ast.rs b/src/ast.rs
index 4339040..a2ba59a 100644
--- a/src/ast.rs
+++ b/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>,
     },
diff --git a/src/main.rs b/src/main.rs
index 7327e20..d1ea654 100644
--- a/src/main.rs
+++ b/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());
 }
diff --git a/src/parser.rs b/src/parser.rs
index 3d7ea49..5c61d4e 100644
--- a/src/parser.rs
+++ b/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,
         })
     }