Implemented break and continue statements as well as added test cases for them

Author: IsaacShelton

Diff for: src/lexer/identifier_state.rs

@@ -48,6 +48,8 @@ impl IdentifierState {
             "for" => TokenKind::ForKeyword,
             "is" => TokenKind::IsKeyword,
             "null" => TokenKind::NullKeyword,
+            "break" => TokenKind::BreakKeyword,
+            "continue" => TokenKind::ContinueKeyword,
             _ => TokenKind::Identifier(identifier),
         }
         .at(self.start_source)

Diff for: src/lower/builder.rs

@@ -10,6 +10,8 @@ pub struct Builder<'a> {
     basicblocks: BasicBlocks,
     current_basicblock_id: usize,
     poly_recipe: &'a PolyRecipe,
+    pub break_basicblock_id: Option<usize>,
+    pub continue_basicblock_id: Option<usize>,
 }
 
 impl<'a> Builder<'a> {
@@ -21,6 +23,8 @@ impl<'a> Builder<'a> {
             basicblocks,
             current_basicblock_id: 0,
             poly_recipe,
+            break_basicblock_id: None,
+            continue_basicblock_id: None,
         }
     }
 

Diff for: src/lower/expr/mod.rs

@@ -6,7 +6,7 @@ use super::{
     cast::{integer_cast, integer_extend, integer_truncate},
     datatype::lower_type,
     error::{LowerError, LowerErrorKind},
-    stmts::lower_stmts,
+    stmts::{lower_stmts, lower_stmts_with_break_and_continue},
 };
 use crate::{
     asg::{
@@ -412,7 +412,16 @@ pub fn lower_expr(
             ));
 
             builder.use_block(true_basicblock_id);
-            lower_stmts(builder, ir_module, &while_loop.block.stmts, function, asg)?;
+            lower_stmts_with_break_and_continue(
+                builder,
+                ir_module,
+                &while_loop.block.stmts,
+                function,
+                asg,
+                Some(false_basicblock_id),
+                Some(evaluate_basicblock_id),
+            )?;
+
             builder.continues_to(evaluate_basicblock_id);
 
             builder.use_block(false_basicblock_id);
@@ -510,15 +519,29 @@ pub fn lower_expr(
             Ok(builder.push(ir::Instr::InterpreterSyscall(*syscall, values)))
         }
         ExprKind::Break => {
+            let Some(target_basicblock_id) = builder.break_basicblock_id else {
+                return Err(LowerErrorKind::Other {
+                    message: "Nowhere to break to".into(),
+                }
+                .at(expr.source));
+            };
+
             builder.push(ir::Instr::Break(Break {
-                basicblock_id: todo!("break"),
+                basicblock_id: target_basicblock_id,
             }));
 
             Ok(ir::Value::Literal(Literal::Void))
         }
         ExprKind::Continue => {
+            let Some(target_basicblock_id) = builder.continue_basicblock_id else {
+                return Err(LowerErrorKind::Other {
+                    message: "Nowhere to continue to".into(),
+                }
+                .at(expr.source));
+            };
+
             builder.push(ir::Instr::Break(Break {
-                basicblock_id: todo!("continue"),
+                basicblock_id: target_basicblock_id,
             }));
 
             Ok(ir::Value::Literal(Literal::Void))

Diff for: src/lower/stmts.rs

@@ -86,3 +86,25 @@ pub fn lower_stmts(
 
     Ok(result)
 }
+
+pub fn lower_stmts_with_break_and_continue(
+    builder: &mut Builder,
+    ir_module: &ir::Module,
+    stmts: &[asg::Stmt],
+    func: &asg::Func,
+    asg: &Asg,
+    break_basicblock_id: Option<usize>,
+    continue_basicblock_id: Option<usize>,
+) -> Result<Value, LowerError> {
+    let prev_break_basicblock_id = builder.break_basicblock_id;
+    let prev_continue_basicblock_id = builder.continue_basicblock_id;
+
+    builder.break_basicblock_id = break_basicblock_id.or(builder.break_basicblock_id);
+    builder.continue_basicblock_id = continue_basicblock_id.or(builder.continue_basicblock_id);
+
+    let result = lower_stmts(builder, ir_module, stmts, func, asg);
+
+    builder.break_basicblock_id = prev_break_basicblock_id;
+    builder.continue_basicblock_id = prev_continue_basicblock_id;
+    result
+}

Diff for: src/parser/parse_expr/primary/mod.rs

@@ -296,6 +296,14 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                     source,
                 ))
             }
+            TokenKind::BreakKeyword => {
+                self.input.advance().kind.unwrap_break_keyword();
+                Ok(ExprKind::Break.at(source))
+            }
+            TokenKind::ContinueKeyword => {
+                self.input.advance().kind.unwrap_continue_keyword();
+                Ok(ExprKind::Continue.at(source))
+            }
             unexpected => Err(ParseError {
                 kind: match unexpected {
                     TokenKind::Error(message) => ParseErrorKind::Lexical {

Diff for: tests/success/break/main.adept

@@ -0,0 +1,18 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+func main {
+    i := int(0)
+
+    while true {
+        if i > 5 {
+            break
+        }
+        
+        printf(c"%d\n", i)
+        i += 1
+    }
+}

Diff for: tests/success/continue/main.adept

@@ -0,0 +1,21 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+func main {
+    i := int(1)
+
+    while i <= 10 {
+        printf(c"%d", i)
+        i += 1
+        
+        if i > 6 {
+            printf(c"\n")
+            continue
+        }
+        
+        printf(c"!\n")
+    }
+}