Add ! suffix to parser

crates/compiler/can/src/expr.rs

@@ -1441,6 +1441,7 @@ pub fn canonicalize_expr<'a>(
                 bad_expr
             );
         }
+        ast::Expr::Suffixed(_) => todo!(),
     };
 
     // At the end, diff used_idents and defined_idents to see which were unused.
@@ -2506,6 +2507,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
             ast::RecordBuilderField::SpaceBefore(_, _)
             | ast::RecordBuilderField::SpaceAfter(_, _) => false,
         }),
+        ast::Expr::Suffixed(_) => todo!(),
     }
 }
 

crates/compiler/can/src/operator.rs

@@ -619,6 +619,7 @@ pub fn desugar_expr<'a>(
             })
         }
         LowLevelDbg(_, _, _) => unreachable!("Only exists after desugaring"),
+        Suffixed(_) => todo!(),
     }
 }
 

crates/compiler/fmt/src/expr.rs

@@ -107,6 +107,7 @@ impl<'a> Formattable for Expr<'a> {
             Tuple(fields) => is_collection_multiline(fields),
             RecordUpdate { fields, .. } => is_collection_multiline(fields),
             RecordBuilder(fields) => is_collection_multiline(fields),
+            Suffixed(subexpr) => subexpr.is_multiline(),
         }
     }
 
@@ -512,6 +513,10 @@ impl<'a> Formattable for Expr<'a> {
             MultipleRecordBuilders { .. } => {}
             UnappliedRecordBuilder { .. } => {}
             IngestedFile(_, _) => {}
+            Suffixed(sub_expr) => {
+                sub_expr.format_with_options(buf, parens, newlines, indent);
+                buf.push('!');
+            }
         }
     }
 }

crates/compiler/fmt/src/spaces.rs

@@ -761,6 +761,7 @@ impl<'a> RemoveSpaces<'a> for Expr<'a> {
             Expr::SpaceBefore(a, _) => a.remove_spaces(arena),
             Expr::SpaceAfter(a, _) => a.remove_spaces(arena),
             Expr::SingleQuote(a) => Expr::Num(a),
+            Expr::Suffixed(a) => a.remove_spaces(arena),
         }
     }
 }

crates/compiler/parse/src/ast.rs

@@ -267,6 +267,9 @@ pub enum Expr<'a> {
     // Collection Literals
     List(Collection<'a, &'a Loc<Expr<'a>>>),
 
+    /// An expression followed by `!``
+    Suffixed(&'a Expr<'a>),
+
     RecordUpdate {
         update: &'a Loc<Expr<'a>>,
         fields: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
@@ -1568,6 +1571,7 @@ impl<'a> Malformed for Expr<'a> {
             PrecedenceConflict(_) |
             MultipleRecordBuilders(_) |
             UnappliedRecordBuilder(_) => true,
+            Suffixed(expr) => expr.is_malformed(),
         }
     }
 }

crates/compiler/parse/src/expr.rs

@@ -311,8 +311,20 @@ fn expr_start<'a>(options: ExprParseOptions) -> impl Parser<'a, Loc<Expr<'a>>, E
 
 fn expr_operator_chain<'a>(options: ExprParseOptions) -> impl Parser<'a, Expr<'a>, EExpr<'a>> {
     line_min_indent(move |arena, state: State<'a>, min_indent: u32| {
-        let (_, expr, state) =
-            loc_possibly_negative_or_negated_term(options).parse(arena, state, min_indent)?;
+        let (_, expr, state) = loc_possibly_negative_or_negated_term(options)
+            .parse(arena, state, min_indent)
+            .map(|(progress, expr, state)| {
+                // If the next thing after the expression is a `!`, then it's Suffixed
+                if state.bytes().starts_with(b"!") {
+                    (
+                        progress,
+                        Loc::at(expr.region, Expr::Suffixed(arena.alloc(expr.value))),
+                        state.advance(1),
+                    )
+                } else {
+                    (progress, expr, state)
+                }
+            })?;
 
         let initial_state = state.clone();
         let end = state.pos();
@@ -1640,7 +1652,7 @@ fn parse_expr_end<'a>(
         Err((MadeProgress, f)) => Err((MadeProgress, f)),
         Ok((
             _,
-            has @ Loc {
+            implements @ Loc {
                 value:
                     Expr::Var {
                         module_name: "",
@@ -1672,17 +1684,17 @@ fn parse_expr_end<'a>(
             }
 
             // Attach any spaces to the `implements` keyword
-            let has = if !expr_state.spaces_after.is_empty() {
+            let implements = if !expr_state.spaces_after.is_empty() {
                 arena
                     .alloc(Implements::Implements)
-                    .with_spaces_before(expr_state.spaces_after, has.region)
+                    .with_spaces_before(expr_state.spaces_after, implements.region)
             } else {
-                Loc::at(has.region, Implements::Implements)
+                Loc::at(implements.region, Implements::Implements)
             };
 
             let args = arguments.into_bump_slice();
             let (_, (type_def, def_region), state) =
-                finish_parsing_ability_def_help(min_indent, name, args, has, arena, state)?;
+                finish_parsing_ability_def_help(min_indent, name, args, implements, arena, state)?;
 
             let mut defs = Defs::default();
 
@@ -1817,6 +1829,18 @@ fn parse_expr_end<'a>(
             }
         }
     }
+    .map(|(progress, expr, state)| {
+        // If the next thing after the expression is a `!`, then it's Suffixed
+        if state.bytes().starts_with(b"!") {
+            (
+                progress,
+                Expr::Suffixed(arena.alloc(expr)),
+                state.advance(1),
+            )
+        } else {
+            (progress, expr, state)
+        }
+    })
 }
 
 pub fn loc_expr<'a>(accept_multi_backpassing: bool) -> impl Parser<'a, Loc<Expr<'a>>, EExpr<'a>> {
@@ -1945,6 +1969,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
         Expr::Str(string) => Pattern::StrLiteral(string),
         Expr::SingleQuote(string) => Pattern::SingleQuote(string),
         Expr::MalformedIdent(string, problem) => Pattern::MalformedIdent(string, problem),
+        Expr::Suffixed(_) => todo!(),
     };
 
     // Now we re-add the spaces
@@ -2997,6 +3022,7 @@ where
             Err((NoProgress, to_error("->", state.pos())))
         }
         "<-" => good!(BinOp::Backpassing, 2),
+        "!" => Err((NoProgress, to_error("!", state.pos()))),
         _ => bad_made_progress!(chomped),
     }
 }

crates/compiler/test_syntax/tests/snapshots/pass/suffixed.expr.result-ast

@@ -0,0 +1,6 @@
+Suffixed(
+    Var {
+        module_name: "Stdout",
+        ident: "line",
+    },
+)

crates/compiler/test_syntax/tests/snapshots/pass/suffixed.expr.roc

@@ -0,0 +1 @@
+Stdout.line!

crates/compiler/test_syntax/tests/snapshots/pass/suffixed_nested.expr.formatted.roc

@@ -0,0 +1 @@
+foo! (bar! baz) (blah stuff)

crates/compiler/test_syntax/tests/snapshots/pass/suffixed_nested.expr.result-ast

@@ -0,0 +1,43 @@
+Apply(
+    @0-3 Suffixed(
+        Var {
+            module_name: "",
+            ident: "foo",
+        },
+    ),
+    [
+        @9-17 ParensAround(
+            Apply(
+                @9-12 Suffixed(
+                    Var {
+                        module_name: "",
+                        ident: "bar",
+                    },
+                ),
+                [
+                    @14-17 Var {
+                        module_name: "",
+                        ident: "baz",
+                    },
+                ],
+                Space,
+            ),
+        ),
+        @22-32 ParensAround(
+            Apply(
+                @22-26 Var {
+                    module_name: "",
+                    ident: "blah",
+                },
+                [
+                    @27-32 Var {
+                        module_name: "",
+                        ident: "stuff",
+                    },
+                ],
+                Space,
+            ),
+        ),
+    ],
+    Space,
+)

crates/compiler/test_syntax/tests/snapshots/pass/suffixed_nested.expr.roc

@@ -0,0 +1 @@
+foo!  (  bar! baz)  ( blah stuff)

crates/compiler/test_syntax/tests/test_snapshots.rs

@@ -441,6 +441,8 @@ mod test_snapshots {
         pass/string_without_escape.expr,
         pass/sub_var_with_spaces.expr,
         pass/sub_with_spaces.expr,
+        pass/suffixed.expr,
+        pass/suffixed_nested.expr,
         pass/tag_pattern.expr,
         pass/ten_times_eleven.expr,
         pass/three_arg_closure.expr,

crates/lang_srv/src/analysis/tokens.rs

@@ -700,6 +700,7 @@ impl IterTokens for Loc<Expr<'_>> {
             Expr::MalformedIdent(_, _) | Expr::MalformedClosure | Expr::PrecedenceConflict(_) => {
                 bumpvec![in arena;]
             }
+            Expr::Suffixed(_) => todo!(),
         }
     }
 }