avoid bloating parse expr size

crates/compiler/can/src/expr.rs

@@ -1251,7 +1251,7 @@ pub fn canonicalize_expr<'a>(
         ast::Expr::Dbg(_, _) => {
             internal_error!("Dbg should have been desugared by now")
         }
-        ast::Expr::LowLevelDbg(source_location, source, message, continuation) => {
+        ast::Expr::LowLevelDbg((source_location, source), message, continuation) => {
             let mut output = Output::default();
 
             let (loc_message, output1) =
@@ -2406,7 +2406,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
         | ast::Expr::MalformedClosure => true,
         // Newlines are disallowed inside interpolation, and these all require newlines
         ast::Expr::Dbg(_, _)
-        | ast::Expr::LowLevelDbg(_, _, _, _)
+        | ast::Expr::LowLevelDbg(_, _, _)
         | ast::Expr::Defs(_, _)
         | ast::Expr::Expect(_, _)
         | ast::Expr::When(_, _)

crates/compiler/can/src/operator.rs

@@ -660,15 +660,17 @@ pub fn desugar_expr<'a>(
             // |> LowLevelDbg
             arena.alloc(Loc {
                 value: LowLevelDbg(
-                    arena.alloc(format!("{}:{}", module_path, line_col.line)),
-                    arena.alloc(dbg_src),
+                    arena.alloc((
+                        &*arena.alloc_str(&format!("{}:{}", module_path, line_col.line)),
+                        &*arena.alloc_str(dbg_src),
+                    )),
                     dbg_str,
                     desugared_continuation,
                 ),
                 region: loc_expr.region,
             })
         }
-        LowLevelDbg(_, _, _, _) => unreachable!("Only exists after desugaring"),
+        LowLevelDbg(_, _, _) => unreachable!("Only exists after desugaring"),
     }
 }
 

crates/compiler/fmt/src/expr.rs

@@ -62,7 +62,7 @@ impl<'a> Formattable for Expr<'a> {
                 condition.is_multiline() || continuation.is_multiline()
             }
             Dbg(condition, continuation) => condition.is_multiline() || continuation.is_multiline(),
-            LowLevelDbg(_, _, _, _) => unreachable!(
+            LowLevelDbg(_, _, _) => unreachable!(
                 "LowLevelDbg should only exist after desugaring, not during formatting"
             ),
 
@@ -438,7 +438,7 @@ impl<'a> Formattable for Expr<'a> {
             Dbg(condition, continuation) => {
                 fmt_dbg(buf, condition, continuation, self.is_multiline(), indent);
             }
-            LowLevelDbg(_, _, _, _) => unreachable!(
+            LowLevelDbg(_, _, _) => unreachable!(
                 "LowLevelDbg should only exist after desugaring, not during formatting"
             ),
             If(branches, final_else) => {

crates/compiler/fmt/src/spaces.rs

@@ -726,7 +726,7 @@ impl<'a> RemoveSpaces<'a> for Expr<'a> {
                 arena.alloc(a.remove_spaces(arena)),
                 arena.alloc(b.remove_spaces(arena)),
             ),
-            Expr::LowLevelDbg(_, _, _, _) => unreachable!(
+            Expr::LowLevelDbg(_, _, _) => unreachable!(
                 "LowLevelDbg should only exist after desugaring, not during formatting"
             ),
             Expr::Apply(a, b, c) => Expr::Apply(

crates/compiler/parse/src/ast.rs

@@ -302,7 +302,7 @@ pub enum Expr<'a> {
     Expect(&'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
     Dbg(&'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
     // This form of debug is a desugared call to roc_dbg
-    LowLevelDbg(&'a str, &'a str, &'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
+    LowLevelDbg(&'a (&'a str, &'a str), &'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
 
     // Application
     /// To apply by name, do Apply(Var(...), ...)
@@ -1537,7 +1537,7 @@ impl<'a> Malformed for Expr<'a> {
             Backpassing(args, call, body) => args.iter().any(|arg| arg.is_malformed()) || call.is_malformed() || body.is_malformed(),
             Expect(condition, continuation) |
             Dbg(condition, continuation) => condition.is_malformed() || continuation.is_malformed(),
-            LowLevelDbg(_, _, condition, continuation) => condition.is_malformed() || continuation.is_malformed(),
+            LowLevelDbg(_, condition, continuation) => condition.is_malformed() || continuation.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(),
             UnaryOp(expr, _) => expr.is_malformed(),

crates/compiler/parse/src/expr.rs

@@ -1933,7 +1933,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
         | Expr::When(_, _)
         | Expr::Expect(_, _)
         | Expr::Dbg(_, _)
-        | Expr::LowLevelDbg(_, _, _, _)
+        | Expr::LowLevelDbg(_, _, _)
         | Expr::MalformedClosure
         | Expr::PrecedenceConflict { .. }
         | Expr::MultipleRecordBuilders { .. }

crates/lang_srv/src/analysis/tokens.rs

@@ -673,7 +673,7 @@ impl IterTokens for Loc<Expr<'_>> {
             Expr::Dbg(e1, e2) => (e1.iter_tokens(arena).into_iter())
                 .chain(e2.iter_tokens(arena))
                 .collect_in(arena),
-            Expr::LowLevelDbg(_, _, e1, e2) => (e1.iter_tokens(arena).into_iter())
+            Expr::LowLevelDbg(_, e1, e2) => (e1.iter_tokens(arena).into_iter())
                 .chain(e2.iter_tokens(arena))
                 .collect_in(arena),
             Expr::Apply(e1, e2, _called_via) => (e1.iter_tokens(arena).into_iter())