Fix a bunch of parser/formatter bugs found in fuzzing

Notably:
* Unified how parens are formatted between (1) when we have a ParensAround, and (2) when we've decided an Apply needs to have parens
* Made unary minus require the be indented to the same level as any other expression continuation. (it used to accidentally have rules meant for binary operators applied)
* Don't apply extra indent to the backpassing continuation in the case that the call does itself require indentation
* Make `try@foo` correctly parse as `try @foo`, so that formatting doesn't change the tree when it adds that space
* Detect more cases where we need to outdent trailing e.g. {} blocks in applies
* Approximately a bagillion other things, 90% of which I added tests for, and none of which affected the formatting of examples or builtins

crates/compiler/parse/src/ast.rs

@@ -28,12 +28,26 @@ pub struct Spaces<'a, T> {
     pub after: &'a [CommentOrNewline<'a>],
 }
 
+impl<'a, T: Copy> ExtractSpaces<'a> for Spaces<'a, T> {
+    type Item = T;
+
+    fn extract_spaces(&self) -> Spaces<'a, T> {
+        *self
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct SpacesBefore<'a, T> {
     pub before: &'a [CommentOrNewline<'a>],
     pub item: T,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct SpacesAfter<'a, T> {
+    pub after: &'a [CommentOrNewline<'a>],
+    pub item: T,
+}
+
 #[derive(Copy, Clone, PartialEq)]
 pub enum Spaced<'a, T> {
     Item(T),
@@ -491,7 +505,11 @@ pub enum Expr<'a> {
     Backpassing(&'a [Loc<Pattern<'a>>], &'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
 
     Dbg,
-    DbgStmt(&'a Loc<Expr<'a>>, &'a Loc<Expr<'a>>),
+    DbgStmt {
+        first: &'a Loc<Expr<'a>>,
+        extra_args: &'a [&'a Loc<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>>),
@@ -627,7 +645,7 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
         Expr::ParensAround(sub_loc_expr) => is_expr_suffixed(sub_loc_expr),
 
         // expression in a closure
-        Expr::Closure(_, sub_loc_expr) => is_expr_suffixed(&sub_loc_expr.value),
+        Expr::Closure(_, _) => false,
 
         // expressions inside a Defs
         Expr::Defs(defs, expr) => {
@@ -671,7 +689,15 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
         Expr::OpaqueRef(_) => false,
         Expr::Backpassing(_, _, _) => false, // TODO: we might want to check this?
         Expr::Dbg => false,
-        Expr::DbgStmt(a, b) => is_expr_suffixed(&a.value) || is_expr_suffixed(&b.value),
+        Expr::DbgStmt {
+            first,
+            extra_args,
+            continuation,
+        } => {
+            is_expr_suffixed(&first.value)
+                || extra_args.iter().any(|a| is_expr_suffixed(&a.value))
+                || is_expr_suffixed(&continuation.value)
+        }
         Expr::LowLevelDbg(_, a, b) => is_expr_suffixed(&a.value) || is_expr_suffixed(&b.value),
         Expr::Try => false,
         Expr::UnaryOp(a, _) => is_expr_suffixed(&a.value),
@@ -930,10 +956,17 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
                     expr_stack.push(&a.value);
                     expr_stack.push(&b.value);
                 }
-                DbgStmt(condition, cont) => {
+                DbgStmt {
+                    first,
+                    extra_args,
+                    continuation,
+                } => {
                     expr_stack.reserve(2);
-                    expr_stack.push(&condition.value);
-                    expr_stack.push(&cont.value);
+                    expr_stack.push(&first.value);
+                    for arg in extra_args.iter() {
+                        expr_stack.push(&arg.value);
+                    }
+                    expr_stack.push(&continuation.value);
                 }
                 LowLevelDbg(_, condition, cont) => {
                     expr_stack.reserve(2);
@@ -2311,6 +2344,7 @@ impl_extract_spaces!(Tag);
 impl_extract_spaces!(AssignedField<T>);
 impl_extract_spaces!(TypeAnnotation);
 impl_extract_spaces!(ImplementsAbility);
+impl_extract_spaces!(ImplementsAbilities);
 
 impl<'a, T: Copy> ExtractSpaces<'a> for Spaced<'a, T> {
     type Item = T;
@@ -2476,7 +2510,7 @@ impl<'a> Malformed for Expr<'a> {
             Defs(defs, body) => defs.is_malformed() || body.is_malformed(),
             Backpassing(args, call, body) => args.iter().any(|arg| arg.is_malformed()) || call.is_malformed() || body.is_malformed(),
             Dbg => false,
-            DbgStmt(condition, continuation) => condition.is_malformed() || continuation.is_malformed(),
+            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,
             Return(return_value, after_return) => return_value.is_malformed() || after_return.is_some_and(|ar| ar.is_malformed()),