Parse `break`, `continue` and `return` expression

2 files changed, 34 insertions, 1 deletions

diff --git a/src/parse/incremental.rs b/src/parse/incremental.rs
index 2edb84ba..9dd5bec1 100644
--- a/src/parse/incremental.rs
+++ b/src/parse/incremental.rs
@@ -548,7 +548,10 @@ impl NodeKind {
             | Self::ShowExpr
             | Self::WrapExpr
             | Self::ImportExpr
-            | Self::IncludeExpr => SuccessionRule::AtomicPrimary,
+            | Self::IncludeExpr
+            | Self::BreakExpr
+            | Self::ContinueExpr
+            | Self::ReturnExpr => SuccessionRule::AtomicPrimary,
 
             // This element always has to remain in the same column so better
             // reparse the whole parent.
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 67e35a5a..a9839ed6 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -405,6 +405,9 @@ fn primary(p: &mut Parser, atomic: bool) -> ParseResult {
         Some(NodeKind::For) => for_expr(p),
         Some(NodeKind::Import) => import_expr(p),
         Some(NodeKind::Include) => include_expr(p),
+        Some(NodeKind::Break) => break_expr(p),
+        Some(NodeKind::Continue) => continue_expr(p),
+        Some(NodeKind::Return) => return_expr(p),
 
         Some(NodeKind::Error(_, _)) => {
             p.eat();
@@ -833,6 +836,33 @@ fn include_expr(p: &mut Parser) -> ParseResult {
     })
 }
 
+/// Parse a break expression.
+fn break_expr(p: &mut Parser) -> ParseResult {
+    p.perform(NodeKind::BreakExpr, |p| {
+        p.eat_assert(&NodeKind::Break);
+        Ok(())
+    })
+}
+
+/// Parse a continue expression.
+fn continue_expr(p: &mut Parser) -> ParseResult {
+    p.perform(NodeKind::ContinueExpr, |p| {
+        p.eat_assert(&NodeKind::Continue);
+        Ok(())
+    })
+}
+
+/// Parse a return expression.
+fn return_expr(p: &mut Parser) -> ParseResult {
+    p.perform(NodeKind::ReturnExpr, |p| {
+        p.eat_assert(&NodeKind::Return);
+        if !p.eof() {
+            expr(p)?;
+        }
+        Ok(())
+    })
+}
+
 /// Parse an identifier.
 fn ident(p: &mut Parser) -> ParseResult {
     match p.peek() {