Revert "cl-ast: Unify break, return, and unary expressions"

This reverts commit adb0fd229c.

compiler/cl-ast/src/ast.rs

@@ -398,6 +398,10 @@ pub enum ExprKind {
     If(If),
     /// A [For] expression: `for` Pattern `in` [`Expr`] [`Block`] [`Else`]?
     For(For),
+    /// A [Break] expression: `break` [`Expr`]?
+    Break(Break),
+    /// A [Return] expression `return` [`Expr`]?
+    Return(Return),
     /// A continue expression: `continue`
     Continue,
 }
@@ -478,8 +482,6 @@ pub enum UnaryKind {
     Not,
     /// A Loop expression: `loop` [`Block`]
     Loop,
-    Break,
-    Return,
     /// Unused
     At,
     /// Unused
@@ -598,3 +600,15 @@ pub struct For {
 pub struct Else {
     pub body: Option<Box<Expr>>,
 }
+
+/// A [Break] expression: `break` [`Expr`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Break {
+    pub body: Option<Box<Expr>>,
+}
+
+/// A [Return] expression `return` [`Expr`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Return {
+    pub body: Option<Box<Expr>>,
+}

compiler/cl-ast/src/ast_impl.rs

@@ -451,6 +451,8 @@ mod display {
                 ExprKind::While(v) => v.fmt(f),
                 ExprKind::If(v) => v.fmt(f),
                 ExprKind::For(v) => v.fmt(f),
+                ExprKind::Break(v) => v.fmt(f),
+                ExprKind::Return(v) => v.fmt(f),
                 ExprKind::Continue => "continue".fmt(f),
             }
         }
@@ -540,8 +542,6 @@ mod display {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 UnaryKind::Loop => "loop ",
-                UnaryKind::Break => "break ",
-                UnaryKind::Return => "return ",
                 UnaryKind::Deref => "*",
                 UnaryKind::Neg => "-",
                 UnaryKind::Not => "!",
@@ -684,6 +684,26 @@ mod display {
             }
         }
     }
+
+    impl Display for Break {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "break")?;
+            match &self.body {
+                Some(body) => write!(f, " {body}"),
+                _ => Ok(()),
+            }
+        }
+    }
+
+    impl Display for Return {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "return")?;
+            match &self.body {
+                Some(body) => write!(f, " {body}"),
+                _ => Ok(()),
+            }
+        }
+    }
 }
 
 mod convert {
@@ -767,6 +787,8 @@ mod convert {
             While => ExprKind::While,
             If => ExprKind::If,
             For => ExprKind::For,
+            Break => ExprKind::Break,
+            Return => ExprKind::Return,
         }
         impl From for Literal {
             bool => Literal::Bool,

compiler/cl-ast/src/ast_visitor/fold.rs

@@ -368,6 +368,14 @@ pub trait Fold {
         let Else { body } = e;
         Else { body: body.map(|e| Box::new(self.fold_expr(*e))) }
     }
+    fn fold_break(&mut self, b: Break) -> Break {
+        let Break { body } = b;
+        Break { body: body.map(|e| Box::new(self.fold_expr(*e))) }
+    }
+    fn fold_return(&mut self, r: Return) -> Return {
+        let Return { body } = r;
+        Return { body: body.map(|e| Box::new(self.fold_expr(*e))) }
+    }
 }
 
 #[inline]
@@ -539,6 +547,8 @@ pub fn or_fold_expr_kind<F: Fold + ?Sized>(folder: &mut F, kind: ExprKind) -> Ex
         ExprKind::While(w) => ExprKind::While(folder.fold_while(w)),
         ExprKind::If(i) => ExprKind::If(folder.fold_if(i)),
         ExprKind::For(f) => ExprKind::For(folder.fold_for(f)),
+        ExprKind::Break(b) => ExprKind::Break(folder.fold_break(b)),
+        ExprKind::Return(r) => ExprKind::Return(folder.fold_return(r)),
         ExprKind::Continue => ExprKind::Continue,
     }
 }

compiler/cl-ast/src/ast_visitor/visit.rs

@@ -322,6 +322,18 @@ pub trait Visit<'a>: Sized {
             self.visit_expr(body)
         }
     }
+    fn visit_break(&mut self, b: &'a Break) {
+        let Break { body } = b;
+        if let Some(body) = body {
+            self.visit_expr(body)
+        }
+    }
+    fn visit_return(&mut self, r: &'a Return) {
+        let Return { body } = r;
+        if let Some(body) = body {
+            self.visit_expr(body)
+        }
+    }
     fn visit_continue(&mut self) {}
 }
 
@@ -461,6 +473,8 @@ pub fn or_visit_expr_kind<'a, V: Visit<'a>>(visitor: &mut V, e: &'a ExprKind) {
         ExprKind::While(w) => visitor.visit_while(w),
         ExprKind::If(i) => visitor.visit_if(i),
         ExprKind::For(f) => visitor.visit_for(f),
+        ExprKind::Break(b) => visitor.visit_break(b),
+        ExprKind::Return(r) => visitor.visit_return(r),
         ExprKind::Continue => visitor.visit_continue(),
     }
 }

compiler/cl-ast/src/desugar/while_else.rs

@@ -21,12 +21,9 @@ fn desugar_while(extents: Span, kind: ExprKind) -> ExprKind {
     match kind {
         // work backwards: fail -> break -> if -> loop
         ExprKind::While(While { cond, pass, fail: Else { body } }) => {
-            let Expr { extents, kind } = body
-                .map(|b| *b)
-                .unwrap_or(Expr { extents, kind: ExprKind::Empty });
             // Preserve the else-expression's extents, if present, or use the parent's extents
-            let kind = ExprKind::Unary(Unary { kind: UnaryKind::Break, tail: kind.into() });
-            let break_expr = Expr { extents, kind };
+            let fail_span = body.as_ref().map(|body| body.extents).unwrap_or(extents);
+            let break_expr = Expr { extents: fail_span, kind: ExprKind::Break(Break { body }) };
 
             let loop_body = If { cond, pass, fail: Else { body: Some(Box::new(break_expr)) } };
             let loop_body = ExprKind::If(loop_body);