Merge pull request #7296 from smores56/proper-try-keyword

Proper `try` keyword

crates/compiler/parse/src/ast.rs

@@ -511,11 +511,13 @@ pub enum Expr<'a> {
         continuation: &'a Loc<Expr<'a>>,
     },
 
-    // This form of debug is a desugared call to roc_dbg
-    LowLevelDbg(&'a (&'a str, &'a str), &'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
-
     /// The `try` keyword that performs early return on errors
     Try,
+    // This form of try is a desugared Result unwrapper
+    LowLevelTry(&'a Loc<Expr<'a>>),
+
+    // This form of debug is a desugared call to roc_dbg
+    LowLevelDbg(&'a (&'a str, &'a str), &'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
 
     // Application
     /// To apply by name, do Apply(Var(...), ...)
@@ -700,6 +702,7 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
         }
         Expr::LowLevelDbg(_, a, b) => is_expr_suffixed(&a.value) || is_expr_suffixed(&b.value),
         Expr::Try => false,
+        Expr::LowLevelTry(loc_expr) => is_expr_suffixed(&loc_expr.value),
         Expr::UnaryOp(a, _) => is_expr_suffixed(&a.value),
         Expr::When(cond, branches) => {
             is_expr_suffixed(&cond.value) || branches.iter().any(|x| is_when_branch_suffixed(x))
@@ -973,6 +976,9 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
                     expr_stack.push(&condition.value);
                     expr_stack.push(&cont.value);
                 }
+                LowLevelTry(loc_expr) => {
+                    expr_stack.push(&loc_expr.value);
+                }
                 Return(return_value, after_return) => {
                     if let Some(after_return) = after_return {
                         expr_stack.reserve(2);
@@ -2513,6 +2519,7 @@ impl<'a> Malformed for Expr<'a> {
             DbgStmt { first, extra_args, continuation } => first.is_malformed() || extra_args.iter().any(|a| a.is_malformed()) || continuation.is_malformed(),
             LowLevelDbg(_, condition, continuation) => condition.is_malformed() || continuation.is_malformed(),
             Try => false,
+            LowLevelTry(loc_expr) => loc_expr.is_malformed(),
             Return(return_value, after_return) => return_value.is_malformed() || after_return.is_some_and(|ar| ar.is_malformed()),
             Apply(func, args, _) => func.is_malformed() || args.iter().any(|arg| arg.is_malformed()),
             BinOps(firsts, last) => firsts.iter().any(|(expr, _)| expr.is_malformed()) || last.is_malformed(),

crates/compiler/parse/src/expr.rs

@@ -2180,6 +2180,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
         | Expr::Dbg
         | Expr::DbgStmt { .. }
         | Expr::LowLevelDbg(_, _, _)
+        | Expr::LowLevelTry(_)
         | Expr::Return(_, _)
         | Expr::MalformedSuffixed(..)
         | Expr::PrecedenceConflict { .. }

crates/compiler/parse/src/normalize.rs

@@ -727,6 +727,7 @@ impl<'a> Normalize<'a> for Expr<'a> {
                 arena.alloc(b.normalize(arena)),
             ),
             Expr::Try => Expr::Try,
+            Expr::LowLevelTry(a) => Expr::LowLevelTry(arena.alloc(a.normalize(arena))),
             Expr::Return(a, b) => Expr::Return(
                 arena.alloc(a.normalize(arena)),
                 b.map(|loc_b| &*arena.alloc(loc_b.normalize(arena))),