Several migration fixes and make some zig parser improvements based on migrated code in the wild (#7716)

crates/cli/src/format.rs

@@ -9,6 +9,7 @@ use roc_can::expr::{DeclarationTag, Declarations, Expr};
 use roc_error_macros::{internal_error, user_error};
 use roc_fmt::def::fmt_defs;
 use roc_fmt::header::fmt_header;
+use roc_fmt::migrate::MigrateError;
 use roc_fmt::Buf;
 use roc_fmt::MigrationFlags;
 use roc_load::{ExecutionMode, FunctionKind, LoadConfig, LoadedModule, LoadingProblem, Threading};
@@ -78,7 +79,7 @@ fn is_roc_file(path: &Path) -> bool {
 pub fn format_files(
     files: std::vec::Vec<PathBuf>,
     mode: FormatMode,
-    flags: MigrationFlags,
+    migrate: bool,
 ) -> Result<(), String> {
     let arena = Bump::new();
     let mut files_to_reformat = Vec::new(); // to track which files failed `roc format --check`
@@ -86,7 +87,7 @@ pub fn format_files(
     for file in flatten_directories(files) {
         let src = std::fs::read_to_string(&file).unwrap();
 
-        match format_src(&arena, &src, flags) {
+        match format_src(&arena, &src, migrate) {
             Ok(buf) => {
                 match mode {
                     FormatMode::CheckOnly => {
@@ -168,6 +169,11 @@ pub fn format_files(
                         unstable_2_file.display()
                     );
                 }
+                FormatProblem::UnsupportedMigration(e) => internal_error!(
+                    "Formatting bug; unsupported migration\n\n\
+                    Migration error was: {:?}\n\n",
+                    e
+                ),
             },
         }
     }
@@ -197,13 +203,28 @@ pub enum FormatProblem {
         formatted_src: String,
         reformatted_src: String,
     },
+    UnsupportedMigration(MigrateError),
 }
 
-pub fn format_src(arena: &Bump, src: &str, flags: MigrationFlags) -> Result<String, FormatProblem> {
+pub fn format_src(arena: &Bump, src: &str, migrate: bool) -> Result<String, FormatProblem> {
     let ast = arena.alloc(parse_all(arena, src).unwrap_or_else(|e| {
         user_error!("Unexpected parse failure when parsing this formatting:\n\n{src}\n\nParse error was:\n\n{:#?}\n\n", e)
     }));
+    let flags = MigrationFlags {
+        snakify: migrate,
+        parens_and_commas: migrate,
+    };
     let mut buf = Buf::new_in(arena, flags);
+
+    if migrate {
+        roc_fmt::migrate::fmt_header(&mut buf, &ast.header)
+            .map_err(FormatProblem::UnsupportedMigration)?;
+        roc_fmt::migrate::fmt_defs(&mut buf, &ast.defs)
+            .map_err(FormatProblem::UnsupportedMigration)?;
+        buf.fmt_end_of_file();
+        return Ok(buf.as_str().to_string());
+    }
+
     fmt_all(&mut buf, ast);
 
     let reparsed_ast = match arena.alloc(parse_all(arena, buf.as_str())) {
@@ -224,9 +245,7 @@ pub fn format_src(arena: &Bump, src: &str, flags: MigrationFlags) -> Result<Stri
     // the PartialEq implementation is returning `false` even when the Debug-formatted impl is exactly the same.
     // I don't have the patience to debug this right now, so let's leave it for another day...
     // TODO: fix PartialEq impl on ast types
-    if !flags.at_least_one_active()
+    if format!("{ast_normalized:?}") != format!("{reparsed_ast_normalized:?}") {
-        && format!("{ast_normalized:?}") != format!("{reparsed_ast_normalized:?}")
-    {
         return Err(FormatProblem::ReformattingChangedAst {
             formatted_src: buf.as_str().to_string(),
             ast_before: format!("{ast_normalized:#?}\n"),
@@ -235,7 +254,7 @@ pub fn format_src(arena: &Bump, src: &str, flags: MigrationFlags) -> Result<Stri
     }
 
     // Now verify that the resultant formatting is _stable_ - i.e. that it doesn't change again if re-formatted
-    let mut reformatted_buf = Buf::new_in(arena, flags);
+    let mut reformatted_buf = Buf::new_in(arena, MigrationFlags::default());
 
     fmt_all(&mut reformatted_buf, reparsed_ast);
 
@@ -483,12 +502,7 @@ main =
     fn test_single_file_needs_reformatting() {
         let dir = tempdir().unwrap();
         let file_path = setup_test_file(dir.path(), "test1.roc", UNFORMATTED_ROC);
-        let flags = MigrationFlags {
+        let result = format_files(vec![file_path.clone()], FormatMode::CheckOnly, false);
-            snakify: false,
-            parens_and_commas: false,
-        };
-
-        let result = format_files(vec![file_path.clone()], FormatMode::CheckOnly, flags);
         assert!(result.is_err());
         assert_eq!(
             result.unwrap_err(),
@@ -506,12 +520,7 @@ main =
         let dir = tempdir().unwrap();
         let file1 = setup_test_file(dir.path(), "test1.roc", UNFORMATTED_ROC);
         let file2 = setup_test_file(dir.path(), "test2.roc", UNFORMATTED_ROC);
-        let flags = MigrationFlags {
+        let result = format_files(vec![file1, file2], FormatMode::CheckOnly, false);
-            snakify: false,
-            parens_and_commas: false,
-        };
-
-        let result = format_files(vec![file1, file2], FormatMode::CheckOnly, flags);
         assert!(result.is_err());
         let error_message = result.unwrap_err();
         assert!(error_message.contains("test1.roc") && error_message.contains("test2.roc"));
@@ -523,12 +532,7 @@ main =
     fn test_no_files_need_reformatting() {
         let dir = tempdir().unwrap();
         let file_path = setup_test_file(dir.path(), "formatted.roc", FORMATTED_ROC);
-        let flags = MigrationFlags {
+        let result = format_files(vec![file_path], FormatMode::CheckOnly, false);
-            snakify: false,
-            parens_and_commas: false,
-        };
-
-        let result = format_files(vec![file_path], FormatMode::CheckOnly, flags);
         assert!(result.is_ok());
 
         cleanup_temp_dir(dir);
@@ -540,15 +544,10 @@ main =
         let file_formatted = setup_test_file(dir.path(), "formatted.roc", FORMATTED_ROC);
         let file1_unformated = setup_test_file(dir.path(), "test1.roc", UNFORMATTED_ROC);
         let file2_unformated = setup_test_file(dir.path(), "test2.roc", UNFORMATTED_ROC);
-        let flags = MigrationFlags {
-            snakify: false,
-            parens_and_commas: false,
-        };
-
         let result = format_files(
             vec![file_formatted, file1_unformated, file2_unformated],
             FormatMode::CheckOnly,
-            flags,
+            false,
         );
         assert!(result.is_err());
         let error_message = result.unwrap_err();

crates/cli/src/main.rs

@@ -13,7 +13,6 @@ use roc_cli::{
 };
 use roc_docs::generate_docs_html;
 use roc_error_macros::{internal_error, user_error};
-use roc_fmt::MigrationFlags;
 use roc_gen_dev::AssemblyBackendMode;
 use roc_gen_llvm::llvm::build::LlvmBackendMode;
 use roc_load::{LoadingProblem, Threading};
@@ -395,10 +394,6 @@ fn main() -> io::Result<()> {
                     false => FormatMode::WriteToFile,
                 }
             };
-            let flags = MigrationFlags {
-                snakify: migrate,
-                parens_and_commas: migrate,
-            };
 
             if from_stdin && matches!(format_mode, FormatMode::WriteToFile) {
                 eprintln!("When using the --stdin flag, either the --check or the --stdout flag must also be specified. (Otherwise, it's unclear what filename to write to!)");
@@ -451,7 +446,7 @@ fn main() -> io::Result<()> {
                     std::process::exit(1);
                 });
 
-                match format_src(&arena, src, flags) {
+                match format_src(&arena, src, migrate) {
                     Ok(formatted_src) => {
                         match format_mode {
                             FormatMode::CheckOnly => {
@@ -483,7 +478,7 @@ fn main() -> io::Result<()> {
                     }
                 }
             } else {
-                match format_files(roc_files, format_mode, flags) {
+                match format_files(roc_files, format_mode, migrate) {
                     Ok(()) => 0,
                     Err(message) => {
                         eprintln!("{message}");

crates/compiler/fmt/src/lib.rs

@@ -24,7 +24,7 @@ pub struct Buf<'a> {
     flags: MigrationFlags,
 }
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Default)]
 pub struct MigrationFlags {
     pub snakify: bool,
     pub parens_and_commas: bool,

crates/compiler/fmt/src/migrate.rs

@@ -1,11 +1,13 @@
-use roc_module::called_via::UnaryOp;
+use bumpalo::collections::String;
+use bumpalo::Bump;
+use roc_module::called_via::{Associativity, BinOp, UnaryOp};
 use roc_parse::{
     ast::{
-        AbilityImpls, AssignedField, Base, Collection, Defs, Expr, FunctionArrow, Header,
+        AbilityImpls, AssignedField, Base, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces,
-        ImplementsAbilities, ImplementsAbility, ImplementsClause, ImportAlias, ImportAsKeyword,
+        FunctionArrow, Header, ImplementsAbilities, ImplementsAbility, ImplementsClause,
-        ImportExposingKeyword, ImportedModuleName, IngestedFileAnnotation, IngestedFileImport,
+        ImportAlias, ImportAsKeyword, ImportExposingKeyword, ImportedModuleName,
-        ModuleImport, ModuleImportParams, Pattern, Spaced, Spaces, SpacesBefore, Tag,
+        IngestedFileAnnotation, IngestedFileImport, ModuleImport, ModuleImportParams, Pattern,
-        TypeAnnotation, TypeDef, TypeHeader, TypeVar, ValueDef,
+        Spaced, Spaces, SpacesBefore, Tag, TypeAnnotation, TypeDef, TypeHeader, TypeVar, ValueDef,
     },
     header::{
         AppHeader, ExposedName, HostedHeader, Keyword, KeywordItem, ModuleHeader, ModuleName,
@@ -25,7 +27,7 @@ use crate::{
     },
     pattern::snakify_camel_ident,
     spaces::fmt_spaces,
-    Buf,
+    Buf, MigrationFlags,
 };
 
 #[derive(Copy, Clone, Debug)]
@@ -76,7 +78,7 @@ impl<F: Fmt> Fmt for AssignedField<'_, F> {
                 buf.indent(indent);
                 buf.push_str(":");
                 buf.spaces(1);
-                loc1.fmt(buf, indent, Suffix::None)?;
+                loc1.fmt(buf, indent, suffix)?;
             }
             AssignedField::OptionalValue(name, comment_or_newlines, loc1) => {
                 buf.indent(indent);
@@ -87,7 +89,7 @@ impl<F: Fmt> Fmt for AssignedField<'_, F> {
                 buf.indent(indent);
                 buf.push_str(":");
                 buf.spaces(1);
-                loc1.fmt(buf, indent, Suffix::None)?;
+                loc1.fmt(buf, indent, suffix)?;
             }
             AssignedField::IgnoredValue(name, comment_or_newlines, loc1) => {
                 buf.indent(indent);
@@ -99,7 +101,7 @@ impl<F: Fmt> Fmt for AssignedField<'_, F> {
                 buf.indent(indent);
                 buf.push_str(":");
                 buf.spaces(1);
-                loc1.fmt(buf, indent, Suffix::None)?;
+                loc1.fmt(buf, indent, suffix)?;
             }
             AssignedField::LabelOnly(name) => {
                 buf.indent(indent);
@@ -127,13 +129,13 @@ pub fn fmt_pattern(
     match pat {
         Pattern::Identifier { ident } => {
             buf.indent(indent);
-            buf.push_str(ident);
+            snakify_camel_ident(buf, ident);
         }
         Pattern::QualifiedIdentifier { module_name, ident } => {
             buf.indent(indent);
             buf.push_str(module_name);
             buf.push('.');
-            buf.push_str(ident);
+            snakify_camel_ident(buf, ident);
         }
         Pattern::Tag(tag) => {
             buf.indent(indent);
@@ -145,16 +147,31 @@ pub fn fmt_pattern(
         }
         Pattern::Apply(loc, locs) => {
             fmt_pattern(buf, indent, &loc.value, Suffix::OpenRound)?;
-            for loc in locs.iter() {
+            for (i, loc) in locs.iter().enumerate() {
-                fmt_pattern(buf, indent, &loc.value, Suffix::Comma)?;
+                let is_last = i == locs.len() - 1;
+                fmt_pattern(
+                    buf,
+                    indent,
+                    &loc.value,
+                    if is_last { Suffix::None } else { Suffix::Comma },
+                )?;
             }
             buf.indent(indent);
             buf.push(')');
         }
         Pattern::PncApply(loc, collection) => {
             fmt_pattern(buf, indent, &loc.value, Suffix::OpenRound)?;
-            for loc in collection.iter() {
+            for (i, loc) in collection.iter().enumerate() {
-                fmt_pattern(buf, indent, &loc.value, Suffix::Comma)?;
+                let is_last = i == collection.len() - 1;
+                fmt_pattern(
+                    buf,
+                    indent,
+                    &loc.value,
+                    if is_last { Suffix::None } else { Suffix::Comma },
+                )?;
+                if !is_last {
+                    buf.spaces(1);
+                }
             }
             if !collection.final_comments().is_empty() {
                 fmt_spaces(buf, collection.final_comments().iter(), indent);
@@ -325,11 +342,7 @@ pub fn fmt_expr(
                 buf.push_str(module_name);
                 buf.push('.');
             }
-            if buf.flags().snakify {
             snakify_camel_ident(buf, ident);
-            } else {
-                buf.push_str(ident);
-            }
         }
         Expr::Underscore(name) => {
             buf.indent(indent);
@@ -465,18 +478,34 @@ pub fn fmt_expr(
         Expr::LowLevelDbg(..) => todo!(),
         Expr::Apply(func, args, _) => {
             fmt_expr(buf, indent, &func.value, Suffix::OpenRound)?;
-            for arg in *args {
+            for (i, arg) in args.iter().enumerate() {
-                // TODO: make the suffix depend on whether we're multiline
+                let is_last = i == args.len() - 1;
-                fmt_expr(buf, indent, &arg.value, Suffix::Comma)?;
+                fmt_expr(
+                    buf,
+                    indent,
+                    &arg.value,
+                    if is_last { Suffix::None } else { Suffix::Comma },
+                )?;
+                if !is_last {
+                    buf.spaces(1);
+                }
             }
             buf.indent(indent);
             buf.push(')');
         }
         Expr::PncApply(func, collection) => {
             fmt_expr(buf, indent, &func.value, Suffix::OpenRound)?;
-            for arg in collection.iter() {
+            for (i, arg) in collection.iter().enumerate() {
-                // TODO: make the suffix depend on whether we're multiline
+                let is_last = i == collection.len() - 1;
-                fmt_expr(buf, indent, &arg.value, Suffix::Comma)?;
+                fmt_expr(
+                    buf,
+                    indent,
+                    &arg.value,
+                    if is_last { Suffix::None } else { Suffix::Comma },
+                )?;
+                if !is_last {
+                    buf.spaces(1);
+                }
             }
             if !collection.final_comments().is_empty() {
                 fmt_spaces(buf, collection.final_comments().iter(), indent);
@@ -485,14 +514,9 @@ pub fn fmt_expr(
             buf.push(')');
         }
         Expr::BinOps(expr_op_pairs, last_expr) => {
-            for (expr, op) in *expr_op_pairs {
+            let arena = buf.text.bump();
-                fmt_expr(buf, indent, &expr.value, Suffix::None)?;
+            let converted = migrate_pizza(buf, arena, expr_op_pairs, **last_expr)?;
-                buf.spaces(1);
+            fmt_converted_ops(buf, indent, &converted, Suffix::None)?;
-                buf.indent(indent);
-                push_op(buf, op.value);
-                buf.spaces(1);
-            }
-            fmt_expr(buf, indent, &last_expr.value, Suffix::None)?;
         }
         Expr::UnaryOp(expr, op) => {
             buf.indent(indent);
@@ -528,10 +552,11 @@ pub fn fmt_expr(
         }
         Expr::When(cond, when_branchs) => {
             buf.indent(indent);
-            buf.push_str("when");
+            buf.push_str("match");
             buf.spaces(1);
             fmt_expr(buf, indent, &cond.value, Suffix::None)?;
             buf.indent(indent);
+            buf.spaces(1);
             buf.push('{');
             buf.ensure_ends_with_newline();
             for branch in when_branchs.iter() {
@@ -599,6 +624,447 @@ pub fn fmt_expr(
     Ok(())
 }
 
+#[derive(Debug)]
+enum MigratedBinOp<'a> {
+    BinOp {
+        lhs: &'a MigratedBinOp<'a>,
+        op: BinOp,
+        rhs: &'a MigratedBinOp<'a>,
+    },
+    Parens(&'a MigratedBinOp<'a>),
+    StaticDispatch {
+        lhs: &'a MigratedBinOp<'a>,
+        before: &'a [CommentOrNewline<'a>],
+        func: &'a str,
+        args: &'a [Expr<'a>],
+        after: &'a [CommentOrNewline<'a>],
+    },
+    FuncStaticDispatch {
+        lhs: &'a MigratedBinOp<'a>,
+        before: &'a [CommentOrNewline<'a>],
+        func: &'a Expr<'a>,
+        args: &'a [Expr<'a>],
+        after: &'a [CommentOrNewline<'a>],
+    },
+    Expr(Expr<'a>),
+}
+
+fn apply_ops<'a>(
+    buf: &Buf<'a>,
+    arena: &'a Bump,
+    stack: &mut Vec<MigratedBinOp<'a>>,
+    ops: &mut Vec<BinOp>,
+    min_precedence: u8,
+) -> Result<(), MigrateError> {
+    while let Some(&op) = ops.last() {
+        if op.precedence() <= min_precedence
+            && (op.associativity() == Associativity::RightAssociative
+                || op.precedence() < min_precedence)
+        {
+            break;
+        }
+
+        ops.pop();
+
+        let rhs = stack.pop().unwrap();
+        let lhs = stack.pop().unwrap();
+
+        let result = match op {
+            BinOp::Pizza => {
+                // Need to migrate to StaticDispatch or FuncStaticDispatch!
+                match rhs {
+                    MigratedBinOp::Expr(expr) => {
+                        let expr = expr.extract_spaces();
+                        match expr.item {
+                            Expr::Apply(func, args, _) => {
+                                if let Some(name) = is_staticable(buf, &func.value) {
+                                    MigratedBinOp::StaticDispatch {
+                                        lhs: maybe_parens(arena, lhs),
+                                        before: expr.before,
+                                        func: arena.alloc_str(name),
+                                        args: arena.alloc_slice_fill_iter(
+                                            args.iter().map(|arg| arg.value),
+                                        ),
+                                        after: expr.after,
+                                    }
+                                } else {
+                                    MigratedBinOp::FuncStaticDispatch {
+                                        lhs: maybe_parens(arena, lhs),
+                                        before: expr.before,
+                                        func: arena.alloc(func.value),
+                                        args: arena.alloc_slice_fill_iter(
+                                            args.iter().map(|arg| arg.value),
+                                        ),
+                                        after: expr.after,
+                                    }
+                                }
+                            }
+                            Expr::Var { module_name, ident } => {
+                                let ident = if buf.flags.snakify {
+                                    snakify_camel_ident_in_bump(buf.text.bump(), ident)
+                                        .into_bump_str()
+                                } else {
+                                    ident
+                                };
+                                if is_static_method(module_name, ident) {
+                                    MigratedBinOp::StaticDispatch {
+                                        lhs: maybe_parens(arena, lhs),
+                                        before: expr.before,
+                                        func: arena.alloc_str(ident),
+                                        args: &[],
+                                        after: expr.after,
+                                    }
+                                } else {
+                                    MigratedBinOp::FuncStaticDispatch {
+                                        lhs: maybe_parens(arena, lhs),
+                                        before: expr.before,
+                                        func: arena.alloc(Expr::Var { module_name, ident }),
+                                        args: &[],
+                                        after: expr.after,
+                                    }
+                                }
+                            }
+                            _ => return Err(MigrateError::PizzaOpRhsNotSupported),
+                        }
+                    }
+                    _ => return Err(MigrateError::PizzaOpRhsNotSupported),
+                }
+            }
+            _ => MigratedBinOp::BinOp {
+                lhs: arena.alloc(lhs),
+                op,
+                rhs: arena.alloc(rhs),
+            },
+        };
+
+        stack.push(result);
+    }
+    Ok(())
+}
+
+fn maybe_parens<'a>(arena: &'a Bump, lhs: MigratedBinOp<'a>) -> &'a MigratedBinOp<'a> {
+    match lhs {
+        MigratedBinOp::Parens(_)
+        | MigratedBinOp::StaticDispatch { .. }
+        | MigratedBinOp::FuncStaticDispatch { .. }
+        | MigratedBinOp::Expr(_) => arena.alloc(lhs),
+        MigratedBinOp::BinOp { .. } => arena.alloc(MigratedBinOp::Parens(arena.alloc(lhs))),
+    }
+}
+
+fn is_staticable<'a>(buf: &Buf<'a>, value: &Expr<'a>) -> Option<&'a str> {
+    match value {
+        Expr::Var { module_name, ident } => {
+            let ident = if buf.flags.snakify {
+                snakify_camel_ident_in_bump(buf.text.bump(), ident).into_bump_str()
+            } else {
+                ident
+            };
+            if is_static_method(module_name, ident) {
+                Some(ident)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+fn is_static_method(module_name: &str, ident: &str) -> bool {
+    match module_name {
+        "Str" => matches!(
+            ident,
+            "concat"
+                | "is_empty"
+                | "join_with"
+                | "split_on"
+                | "repeat"
+                | "count_utf8_bytes"
+                | "to_utf8"
+                | "starts_with"
+                | "ends_with"
+                | "trim"
+                | "trim_start"
+                | "trim_end"
+                | "to_dec"
+                | "to_f64"
+                | "to_f32"
+                | "to_u128"
+                | "to_i128"
+                | "to_u64"
+                | "to_i64"
+                | "to_u32"
+                | "to_i32"
+                | "to_u16"
+                | "to_i16"
+                | "to_u8"
+                | "to_i8"
+                | "replace_each"
+                | "replace_first"
+                | "replace_last"
+                | "split_first"
+                | "split_last"
+                | "walk_utf8"
+                | "walk_utf8_with_index"
+                | "reserve"
+                | "release_excess_capacity"
+                | "with_prefix"
+                | "contains"
+                | "drop_prefix"
+                | "drop_suffix"
+                | "with_ascii_lowercased"
+                | "with_ascii_uppercased"
+                | "caseless_ascii_equals"
+        ),
+
+        // TODO: other modules
+        "List" => matches!(
+            ident,
+            "is_empty"
+                | "get"
+                | "set"
+                | "replace"
+                | "update"
+                | "append"
+                | "append_if_ok"
+                | "prepend"
+                | "prepend_if_ok"
+                | "map"
+                | "len"
+                | "walk_backwards"
+                | "concat"
+                | "first"
+                | "single"
+                | "repeat"
+                | "reverse"
+                | "join"
+                | "keep_if"
+                | "contains"
+                | "sum"
+                | "walk"
+                | "last"
+                | "keep_oks"
+                | "keep_errs"
+                | "map_with_index"
+                | "map2"
+                | "map3"
+                | "product"
+                | "walk_with_index"
+                | "walk_until"
+                | "walk_with_index_until"
+                | "walk_from"
+                | "walk_from_until"
+                | "range"
+                | "sort_with"
+                | "swap"
+                | "drop_at"
+                | "min"
+                | "max"
+                | "map4"
+                | "map_try"
+                | "walk_try"
+                | "join_map"
+                | "any"
+                | "take_first"
+                | "take_last"
+                | "drop_first"
+                | "drop_last"
+                | "find_first"
+                | "find_last"
+                | "find_first_index"
+                | "find_last_index"
+                | "sublist"
+                | "intersperse"
+                | "split_at"
+                | "split_on"
+                | "split_on_list"
+                | "split_first"
+                | "split_last"
+                | "starts_with"
+                | "ends_with"
+                | "all"
+                | "drop_if"
+                | "sort_asc"
+                | "sort_desc"
+                | "reserve"
+                | "release_excess_capacity"
+                | "walk_backwards_until"
+                | "count_if"
+                | "chunks_of"
+                | "concat_utf8"
+                | "for_each!"
+                | "for_each_try!"
+                | "walk!"
+                | "walk_try!"
+        ),
+        "Dict" => {
+            matches!(
+                ident,
+                "clear"
+                    | "capacity"
+                    | "reserve"
+                    | "release_excess_capacity"
+                    | "len"
+                    | "is_empty"
+                    | "get"
+                    | "contains"
+                    | "insert"
+                    | "remove"
+                    | "update"
+                    | "walk"
+                    | "walk_until"
+                    | "keep_if"
+                    | "drop_if"
+                    | "to_list"
+                    | "keys"
+                    | "values"
+                    | "insert_all"
+                    | "keep_shared"
+                    | "remove_all"
+                    | "map"
+                    | "join_map"
+            )
+        }
+        _ => false,
+    }
+}
+
+fn migrate_pizza<'a>(
+    buf: &Buf<'a>,
+    arena: &'a Bump,
+    expr_op_pairs: &[(Loc<Expr<'a>>, Loc<BinOp>)],
+    last_expr: Loc<Expr<'a>>,
+) -> Result<MigratedBinOp<'a>, MigrateError> {
+    println!(
+        "Starting migrate_pizza with {} expr_op_pairs",
+        expr_op_pairs.len()
+    );
+
+    let mut stack: Vec<MigratedBinOp<'a>> = Vec::new();
+    let mut ops: Vec<BinOp> = Vec::new();
+
+    for (expr, op) in expr_op_pairs {
+        println!("Processing expression: {:?}", expr.value);
+        stack.push(MigratedBinOp::Expr(expr.value));
+        apply_ops(buf, arena, &mut stack, &mut ops, op.value.precedence())?;
+
+        println!("Pushing operator onto stack: {:?}", op.value);
+        ops.push(op.value);
+    }
+
+    // Push the last expression onto the stack
+    println!("Pushing last expression onto stack: {:?}", last_expr.value);
+    stack.push(MigratedBinOp::Expr(last_expr.value));
+
+    // Apply all remaining operators
+    println!("Applying all remaining operators (min_precedence: 0)");
+    apply_ops(buf, arena, &mut stack, &mut ops, 0)?;
+    println!("Final stack size: {}", stack.len());
+
+    // The final result should be at the top of the stack
+    let result = stack.pop().unwrap();
+    println!("Returning final result: {:?}", result);
+    Ok(result)
+}
+
+fn fmt_converted_ops(
+    buf: &mut Buf,
+    indent: u16,
+    converted: &MigratedBinOp,
+    suffix: Suffix,
+) -> Result<(), MigrateError> {
+    match converted {
+        MigratedBinOp::BinOp { lhs, op, rhs } => {
+            // Format left-hand side
+            fmt_converted_ops(buf, indent, lhs, Suffix::None)?;
+
+            // Format operator
+            buf.indent(indent);
+            buf.spaces(1);
+            push_op(buf, *op);
+            buf.spaces(1);
+
+            // Format right-hand side
+            fmt_converted_ops(buf, indent, rhs, suffix)?;
+        }
+        MigratedBinOp::Expr(expr) => {
+            fmt_expr(buf, indent, expr, suffix)?;
+        }
+        MigratedBinOp::Parens(inner) => {
+            buf.push('(');
+            fmt_converted_ops(buf, indent, inner, Suffix::None)?;
+            buf.indent(indent);
+            buf.push(')');
+            fmt_suffix(buf, indent, suffix);
+        }
+        MigratedBinOp::StaticDispatch {
+            lhs,
+            before,
+            func,
+            args,
+            after,
+        } => {
+            // lhs.func(args)
+            fmt_converted_ops(buf, indent, lhs, Suffix::None)?;
+            if !before.is_empty() {
+                fmt_spaces(buf, before.iter(), indent);
+            }
+            buf.indent(indent);
+            buf.push('.');
+            buf.push_str(func);
+            buf.push('(');
+            for (i, arg) in args.iter().enumerate() {
+                fmt_expr(buf, indent, arg, Suffix::None)?;
+                if i != args.len() - 1 {
+                    buf.indent(indent);
+                    buf.push(',');
+                    buf.spaces(1);
+                }
+            }
+            buf.indent(indent);
+            buf.push(')');
+            fmt_suffix(buf, indent, suffix);
+            if !after.is_empty() {
+                fmt_spaces(buf, after.iter(), indent);
+            }
+        }
+        MigratedBinOp::FuncStaticDispatch {
+            lhs,
+            before,
+            func,
+            args,
+            after,
+        } => {
+            // lhs.(func)(args)
+            fmt_converted_ops(buf, indent, lhs, Suffix::None)?;
+            if !before.is_empty() {
+                fmt_spaces(buf, before.iter(), indent);
+            }
+            buf.indent(indent);
+            buf.push('.');
+            buf.push('(');
+            fmt_expr(buf, indent, func, Suffix::None)?;
+            buf.push(')');
+            buf.push('(');
+            for (i, arg) in args.iter().enumerate() {
+                fmt_expr(buf, indent, arg, Suffix::None)?;
+                if i != args.len() - 1 {
+                    buf.indent(indent);
+                    buf.push(',');
+                    buf.spaces(1);
+                }
+            }
+            buf.indent(indent);
+            buf.push(')');
+            fmt_suffix(buf, indent, suffix);
+            if !after.is_empty() {
+                fmt_spaces(buf, after.iter(), indent);
+            }
+        }
+    }
+    Ok(())
+}
+
 pub fn fmt_expr_top_level(
     buf: &mut Buf<'_>,
     indent: u16,
@@ -691,8 +1157,16 @@ fn fmt_collection<F: Fmt>(
         }
     }
 
-    for item in collection.iter() {
+    for (i, item) in collection.iter().enumerate() {
-        item.fmt(buf, indent + 4, Suffix::Comma)?;
+        let is_last = i == collection.len() - 1 && tail.is_none();
+        item.fmt(
+            buf,
+            indent + 4,
+            if is_last { Suffix::None } else { Suffix::Comma },
+        )?;
+        if !is_last {
+            buf.spaces(1);
+        }
     }
 
     if let Some(tail) = tail {
@@ -743,12 +1217,22 @@ impl Fmt for TypeHeader<'_> {
     fn fmt(&self, buf: &mut Buf, indent: u16, suffix: Suffix) -> Result<(), MigrateError> {
         buf.indent(indent);
         buf.push_str(self.name.value);
+        if !self.vars.is_empty() {
             buf.push('(');
-        for arg in self.vars {
+            for (i, arg) in self.vars.iter().enumerate() {
-            arg.fmt(buf, indent, Suffix::Comma)?;
+                let is_last = i == self.vars.len() - 1;
+                arg.fmt(
+                    buf,
+                    indent,
+                    if is_last { Suffix::None } else { Suffix::Comma },
+                )?;
+                if !is_last {
+                    buf.spaces(1);
+                }
             }
             buf.indent(indent);
             buf.push(')');
+        }
         fmt_suffix(buf, indent, suffix);
         Ok(())
     }
@@ -762,8 +1246,16 @@ impl Fmt for Tag<'_> {
                 buf.push_str(name.value);
                 if !args.is_empty() {
                     buf.push('(');
-                    for arg in args.iter() {
+                    for (i, arg) in args.iter().enumerate() {
-                        arg.fmt(buf, indent, Suffix::Comma)?;
+                        let is_last = i == args.len() - 1;
+                        arg.fmt(
+                            buf,
+                            indent,
+                            if is_last { Suffix::None } else { Suffix::Comma },
+                        )?;
+                        if !is_last {
+                            buf.spaces(1);
+                        }
                     }
                     buf.indent(indent);
                     buf.push(')');
@@ -788,8 +1280,16 @@ impl Fmt for TypeAnnotation<'_> {
     fn fmt(&self, buf: &mut Buf, indent: u16, suffix: Suffix) -> Result<(), MigrateError> {
         match self {
             TypeAnnotation::Function(args, function_arrow, res) => {
-                for arg in args.iter() {
+                for (i, arg) in args.iter().enumerate() {
-                    arg.fmt(buf, indent, Suffix::Comma)?;
+                    let is_last = i == args.len() - 1;
+                    arg.fmt(
+                        buf,
+                        indent,
+                        if is_last { Suffix::None } else { Suffix::Comma },
+                    )?;
+                    if !is_last {
+                        buf.spaces(1);
+                    }
                 }
                 match function_arrow {
                     FunctionArrow::Pure => {
@@ -811,8 +1311,16 @@ impl Fmt for TypeAnnotation<'_> {
                 buf.push_str(func);
                 if !locs.is_empty() {
                     buf.push('(');
-                    for loc in locs.iter() {
+                    for (i, loc) in locs.iter().enumerate() {
-                        loc.fmt(buf, indent, Suffix::Comma)?;
+                        let is_last = i == locs.len() - 1;
+                        loc.fmt(
+                            buf,
+                            indent,
+                            if is_last { Suffix::None } else { Suffix::Comma },
+                        )?;
+                        if !is_last {
+                            buf.spaces(1);
+                        }
                     }
                     buf.indent(indent);
                     buf.push(')');
@@ -865,8 +1373,7 @@ impl Fmt for TypeAnnotation<'_> {
                 buf.push_str("_");
             }
             TypeAnnotation::Wildcard => {
-                buf.indent(indent);
+                return Err(MigrateError::WildcardTypeNotSupported);
-                buf.push_str("*");
             }
             TypeAnnotation::Where(left, clauses) => {
                 left.fmt(buf, indent, Suffix::None)?;
@@ -1022,6 +1529,11 @@ impl Fmt for TypeDef<'_> {
                 typ,
                 derived,
             } => {
+                if true {
+                    // current new compiler doesn't support opaque types
+                    // TODO: fix this!
+                    return Err(MigrateError::OpaqueNotSupported);
+                }
                 header.fmt(buf, indent, Suffix::None)?;
                 buf.push_str(" :=");
                 buf.spaces(1);
@@ -1046,11 +1558,14 @@ impl Fmt for TypeDef<'_> {
 #[derive(Debug)]
 pub enum MigrateError {
     AbilitiesNotSupported,
+    WildcardTypeNotSupported,
     MalformedIdentNotSupported,
     MalformedPatternNotSupported,
     MalformedPatternIdentNotSupported,
     MalformedPatternAsExprNotSupported,
     PrecedenceConflictNotSupported,
+    OpaqueNotSupported,
+    PizzaOpRhsNotSupported,
 }
 
 impl Fmt for ValueDef<'_> {
@@ -1133,6 +1648,7 @@ impl Fmt for IngestedFileImport<'_> {
 
         buf.indent(indent);
         buf.push_str("import");
+        buf.spaces(1);
 
         let indent = indent + 4;
 
@@ -1236,6 +1752,7 @@ impl Fmt for ModuleImport<'_> {
 
         buf.indent(indent);
         buf.push_str("import");
+        buf.spaces(1);
 
         if !before_name.is_empty() {
             fmt_spaces(buf, before_name.iter(), indent);
@@ -1250,10 +1767,13 @@ impl Fmt for ModuleImport<'_> {
         }
 
         if let Some(exposed) = exposed {
+            buf.spaces(1);
             exposed.keyword.fmt(buf, indent, Suffix::None)?;
+            buf.spaces(1);
             fmt_collection(buf, indent, Braces::Square, None, exposed.item, None)?;
         }
         fmt_suffix(buf, indent, suffix);
+        buf.ensure_ends_with_newline();
         Ok(())
     }
 }
@@ -1399,3 +1919,9 @@ pub fn fmt_defs(buf: &mut Buf<'_>, defs: &Defs<'_>) -> Result<(), MigrateError>
     }
     Ok(())
 }
+
+fn snakify_camel_ident_in_bump<'a>(arena: &'a Bump, string: &str) -> String<'a> {
+    let mut buf = Buf::new_in(arena, MigrationFlags::default());
+    snakify_camel_ident(&mut buf, string);
+    buf.text
+}

crates/compiler/module/src/called_via.rs

@@ -216,7 +216,7 @@ impl BinOp {
         ASSOCIATIVITY_TABLE[self as usize]
     }
 
-    fn precedence(self) -> u8 {
+    pub fn precedence(self) -> u8 {
         const PRECEDENCE_TABLE: [u8; 18] = generate_precedence_table();
 
         PRECEDENCE_TABLE[self as usize]

crates/compiler/test_syntax/tests/snapshots/malformed/if_in_record_field_opt_pat.expr.migrated.roc

@@ -5,6 +5,6 @@ O({p: if
         A
     } else {
         &m
-    }}, #
+    }} #
 ) : e
 i

crates/compiler/test_syntax/tests/snapshots/malformed/looks_like_implements.expr.migrated.roc

@@ -1,2 +1,2 @@
-N((implements),h,(0),) : B
+N((implements), h, (0)) : B
 T

crates/compiler/test_syntax/tests/snapshots/malformed/negative_number_in_pattern.expr.migrated.roc

@@ -1,2 +1,2 @@
-N(-0,T,) : A
+N(-0, T) : A
 zT

crates/compiler/test_syntax/tests/snapshots/malformed/opaque_in_ann_apply_arg.expr.migrated.roc

@@ -1,4 +1,4 @@
-B(@A,) : w
+B(@A) : w
 #
 @A = e
 i

crates/compiler/test_syntax/tests/snapshots/malformed/parens_comment_in_ty_annotation.expr.migrated.roc

@@ -1,3 +1,3 @@
 Zx((e #
-),f,) : i
+), f) : i
 s

crates/compiler/test_syntax/tests/snapshots/malformed/parens_in_type_def_apply.expr.migrated.roc

@@ -1,2 +1,2 @@
-U((b(a,)),) : b
+U((b(a))) : b
 a

crates/compiler/test_syntax/tests/snapshots/malformed/pattern_opt_field_bonanza.expr.migrated.roc

@@ -1,4 +1,4 @@
 M({s: s({J&
-    },)},{s: s({J&
+    })}, {s: s({J&
-    },)},) : p
+    })}) : p
 y

crates/compiler/test_syntax/tests/snapshots/malformed/quotes_in_parens_in_pat.expr.migrated.roc

@@ -1,4 +1,4 @@
 Q((
 """
-"""("",)),) : a
+"""(""))) : a
 q

crates/compiler/test_syntax/tests/snapshots/malformed/repr_7346.expr.migrated.roc

@@ -1,6 +1,6 @@
 il3(|k| # w#z
 {
-    CCC(@C,( # i
+    CCC(@C, ( # i
-    t!(K,)),) : i
+    t!(K))) : i
     C
-},)
+})

crates/compiler/test_syntax/tests/snapshots/pass/alias_ann_in_parens.expr.migrated.roc

@@ -1,3 +1,3 @@
-M() :
+M :
 r
 h

crates/compiler/test_syntax/tests/snapshots/pass/alias_comment_after_head.expr.migrated.roc

@@ -1,3 +1,3 @@
 A( #
-p,) : e
+p) : e
 A

crates/compiler/test_syntax/tests/snapshots/pass/alias_parens_comment.expr.migrated.roc

@@ -1,3 +1,3 @@
-K() : #
+K : #
 s
 K

crates/compiler/test_syntax/tests/snapshots/pass/alias_parens_comment_indent.expr.migrated.roc

@@ -1,4 +1,4 @@
-O() : O(z,
+O : O(z
 #
 )
 b #

crates/compiler/test_syntax/tests/snapshots/pass/ann_apply_record_with_newlines.expr.migrated.roc

@@ -1,4 +1,4 @@
 8: O(
 {
-},)
+})
 Q

crates/compiler/test_syntax/tests/snapshots/pass/ann_closed_union.expr.migrated.roc

@@ -1,4 +1,4 @@
-foo: [True,Perhaps(Thing,),]
+foo: [True, Perhaps(Thing)]
 foo = True
 
 42

crates/compiler/test_syntax/tests/snapshots/pass/ann_effectful_fn.expr.migrated.roc

@@ -1,5 +1,5 @@
-launchTheNukes: {}, => Result(Bool,LaunchNukeErr,)
+launchTheNukes: {} => Result(Bool, LaunchNukeErr)
 launchTheNukes = |{}|
-crash("todo",)
+crash("todo")
 
 launchTheNukes

crates/compiler/test_syntax/tests/snapshots/pass/ann_parens_where_implements_func.expr.migrated.roc

@@ -1,5 +1,5 @@
 x: a
  where
 e
- implements K, -> Z
+ implements K -> Z
 s

crates/compiler/test_syntax/tests/snapshots/pass/ann_pattern_comment_before_body.expr.migrated.roc

@@ -1,4 +1,4 @@
-H() : p
+H : p
 #
 s = p
 d #

crates/compiler/test_syntax/tests/snapshots/pass/ann_record_pat_with_comment.expr.migrated.roc

@@ -1,3 +1,3 @@
-{l: s, #
+{l: s #
 }: s
 o

crates/compiler/test_syntax/tests/snapshots/pass/ann_tag_union_newline_comment.expr.migrated.roc

@@ -1,4 +1,4 @@
 k:
-[T,..m
+[T, ..m
 ] #
 D

crates/compiler/test_syntax/tests/snapshots/pass/ann_where_e_newline_implements.expr.migrated.roc

@@ -1,4 +1,4 @@
-J() : [
+J : [
 ] where e
  implements T
 i

crates/compiler/test_syntax/tests/snapshots/pass/annotate_tuple_func.expr.migrated.roc

@@ -1,3 +1,3 @@
 1: (f,
-    ww, -> p,..e)
+    ww -> p, ..e)
 Mh

crates/compiler/test_syntax/tests/snapshots/pass/annotated_record_destructure.expr.migrated.roc

@@ -1,4 +1,4 @@
-{x,y,}: Foo
+{x, y}: Foo
-{x,y,} = {x: "foo"y: 3.14}
+{x, y} = {x: "foo", y: 3.14}
 
 x

crates/compiler/test_syntax/tests/snapshots/pass/annotated_tag_destructure.expr.migrated.roc

@@ -1,4 +1,4 @@
-UserId(x,): [UserId(I64,),]
+UserId(x): [UserId(I64)]
-UserId(x,) = UserId(42,)
+UserId(x) = UserId(42)
 
 x

crates/compiler/test_syntax/tests/snapshots/pass/annotated_tuple_destructure.expr.migrated.roc

@@ -1,4 +1,4 @@
-(x,y,): Foo
+(x, y): Foo
-(x,y,) = ("foo",3.14,)
+(x, y) = ("foo", 3.14)
 
 x

crates/compiler/test_syntax/tests/snapshots/pass/annotation_apply_newlines.expr.migrated.roc

@@ -1,4 +1,4 @@
 A(
-p,) :
+p) :
 e
 A

crates/compiler/test_syntax/tests/snapshots/pass/annotation_comment_before_as.expr.migrated.roc

@@ -1,3 +1,3 @@
 e: A #
-as H()
+as H
 n

crates/compiler/test_syntax/tests/snapshots/pass/annotation_comment_before_colon.expr.migrated.roc

@@ -1,4 +1,4 @@
 A(
-e, # g
+e # g
 ) : A
 AA

crates/compiler/test_syntax/tests/snapshots/pass/annotation_double_as.expr.migrated.roc

@@ -1,2 +1,2 @@
-s: eas A()as A()
+s: eas Aas A
 s

crates/compiler/test_syntax/tests/snapshots/pass/annotation_tag_parens_comment.expr.migrated.roc

@@ -1,3 +1,3 @@
-g: [T(T, #
+g: [T(T #
-    ),]
+    )]
 D

crates/compiler/test_syntax/tests/snapshots/pass/annotation_tuple_comment.expr.migrated.roc

@@ -1,3 +1,3 @@
 3: (..n #
-), -> n
+) -> n
 0

crates/compiler/test_syntax/tests/snapshots/pass/annotation_tuple_newline.expr.migrated.roc

@@ -1,3 +1,3 @@
-d: (J,..g
+d: (J, ..g
 )
 2

crates/compiler/test_syntax/tests/snapshots/pass/annotation_tuples_ext_galore.expr.migrated.roc

@@ -1,2 +1,2 @@
-1: ((),..n)
+1: ((), ..n)
 l

crates/compiler/test_syntax/tests/snapshots/pass/applies_in_binop.expr.migrated.roc

@@ -1,3 +1,3 @@
-Str.getUnsafe(haystack,haystackIndex,)
+Str.getUnsafe(haystack, haystackIndex)
-==
+ ==
-Str.getUnsafe(needle,needleIndex,)
+Str.getUnsafe(needle, needleIndex)

crates/compiler/test_syntax/tests/snapshots/pass/apply_bang_bang_closure.expr.migrated.roc

@@ -1,3 +1,3 @@
 !!
 |w| 2(
-n,)
+n)

crates/compiler/test_syntax/tests/snapshots/pass/apply_closure_pizza.expr.migrated.roc

@@ -1,2 +1,2 @@
 foo
-|> Dict.keepIf(|(k,_v,)| List.contains(keysToDelete,k,) |> Bool.not,)
+.(Dict.keepIf)(|(k, _v)| List.contains(keysToDelete, k).(Bool.not)())

crates/compiler/test_syntax/tests/snapshots/pass/apply_parenthetical_tag_args.expr.migrated.roc

@@ -1 +1 @@
-Whee((12),(34),)
+Whee((12), (34))

crates/compiler/test_syntax/tests/snapshots/pass/apply_record_ann.expr.migrated.roc

@@ -1,3 +1,3 @@
 a: N({h
-},)
+})
 g

crates/compiler/test_syntax/tests/snapshots/pass/apply_record_parens_newline_field.expr.migrated.roc

@@ -1,2 +1,2 @@
-0({lxtl: (se #
+0({l xt l: (se #
-    )},)
+    )})

crates/compiler/test_syntax/tests/snapshots/pass/apply_tag.expr.migrated.roc

@@ -1 +1 @@
-Whee(12,34,)
+Whee(12, 34)

crates/compiler/test_syntax/tests/snapshots/pass/apply_tag_pnc.expr.migrated.roc

@@ -1 +1 @@
-Whee(12,34,)
+Whee(12, 34)

crates/compiler/test_syntax/tests/snapshots/pass/apply_tag_single_arg_pnc.pattern.migrated.roc

@@ -1 +1 @@
-Ok(a,)
+Ok(a)

crates/compiler/test_syntax/tests/snapshots/pass/apply_tag_single_arg_whitespace.pattern.migrated.roc

@@ -1 +1 @@
-Ok(a,)
+Ok(a)

crates/compiler/test_syntax/tests/snapshots/pass/apply_three_args.expr.migrated.roc

@@ -1 +1 @@
-a(b,c,d,)
+a(b, c, d)

crates/compiler/test_syntax/tests/snapshots/pass/apply_tuple_ext_parens_ty.expr.migrated.roc

@@ -1,2 +1,2 @@
-i: M((),c,)
+i: M((), c)
 t

crates/compiler/test_syntax/tests/snapshots/pass/apply_two_args.expr.migrated.roc

@@ -1 +1 @@
-whee(12,34,)
+whee(12, 34)

crates/compiler/test_syntax/tests/snapshots/pass/apply_two_args_pnc.expr.migrated.roc

@@ -1 +1 @@
-whee(12,34,)
+whee(12, 34)

crates/compiler/test_syntax/tests/snapshots/pass/apply_unary_negation.expr.migrated.roc

@@ -1 +1 @@
--whee(12,foo,)
+-whee(12, foo)

crates/compiler/test_syntax/tests/snapshots/pass/apply_unary_not.expr.migrated.roc

@@ -1 +1 @@
-!whee(12,foo,)
+!whee(12, foo)

crates/compiler/test_syntax/tests/snapshots/pass/arg_pattern_as.expr.migrated.roc

@@ -1,2 +1,2 @@
-|{x,y,} as point@Location(inner,) as outer|
+|{x, y} as point@Location(inner) as outer|
-crash("",)
+crash("")

crates/compiler/test_syntax/tests/snapshots/pass/as_in_func_type_args.expr.migrated.roc

@@ -1,3 +1,3 @@
 e: J
-as H(), -> A
+as H -> A
 r

crates/compiler/test_syntax/tests/snapshots/pass/bangs_and_tuple_accessors.expr.migrated.roc

@@ -1,3 +1,3 @@
 J
 !
-.1(!.0,)
+.1(!.0)

crates/compiler/test_syntax/tests/snapshots/pass/basic_apply.expr.migrated.roc

@@ -1 +1 @@
-whee(1,)
+whee(1)

crates/compiler/test_syntax/tests/snapshots/pass/basic_tuple.expr.migrated.roc

@@ -1 +1 @@
-(1,2,3,)
+(1, 2, 3)

crates/compiler/test_syntax/tests/snapshots/pass/binop_apply_complex.expr.migrated.roc

@@ -1 +1 @@
-N < l((r * N),)
+N < l((r * N))

crates/compiler/test_syntax/tests/snapshots/pass/binop_closure_apply.expr.migrated.roc

@@ -1,3 +1,3 @@
 d +
 (|w| x)(
-x,)
+x)

crates/compiler/test_syntax/tests/snapshots/pass/binops_comment_indent_change.expr.migrated.roc

@@ -1,4 +1,4 @@
 r ^
 -f(
 #
--P,)
+-P)

crates/compiler/test_syntax/tests/snapshots/pass/body_block_string_apply_string.expr.migrated.roc

@@ -1,5 +1,5 @@
 t =
 """
 " 
-"""("",)
+"""("")
 S

crates/compiler/test_syntax/tests/snapshots/pass/call_bang.expr.migrated.roc

@@ -1 +1 @@
-launchTheNukes!(123,)
+launchTheNukes!(123)

crates/compiler/test_syntax/tests/snapshots/pass/call_bang_no_space.expr.migrated.roc

@@ -1 +1 @@
-fxFn!(arg,)
+fxFn!(arg)

crates/compiler/test_syntax/tests/snapshots/pass/can_ignored_field_in_import.expr.migrated.roc

@@ -1,3 +1,4 @@
-importP{_: h
+import P{_: h
 }
+
 t!

crates/compiler/test_syntax/tests/snapshots/pass/closure_complex_pattern_indent_issue.expr.migrated.roc

@@ -1,4 +1,4 @@
 |I({p? Y(
-    Y,)?,},[
+    Y)?},[
-],)|
+])|
 K # (

crates/compiler/test_syntax/tests/snapshots/pass/closure_in_apply_in_binop.expr.migrated.roc

@@ -1,2 +1,2 @@
-m0(|w| w?(e,),)
+m0(|w| w?(e))
-/ s
+ / s

crates/compiler/test_syntax/tests/snapshots/pass/closure_parens_double_newlines.expr.migrated.roc

@@ -1,3 +1,3 @@
-|L(z,
+|L(z
 
 )| 42

crates/compiler/test_syntax/tests/snapshots/pass/closure_pat_reccord_comment.expr.migrated.roc

@@ -1,2 +1,2 @@
 |{i, #
-    e,}| a
+    e}| a

crates/compiler/test_syntax/tests/snapshots/pass/closure_with_binops_and_unary.expr.migrated.roc

@@ -1,3 +1,3 @@
 m
-^ (-|w| m)(
+ ^ (-|w| m)(
-w,)
+w)

crates/compiler/test_syntax/tests/snapshots/pass/comma_prefixed_indented_record.expr.migrated.roc

@@ -1,8 +1,8 @@
-Model(position,) :
+Model(position) :
-{evaluated: Set(position,)
+{evaluated: Set(position),
-    openSet: Set(position,)
+    openSet: Set(position),
-    costs: Dict.Dict(position,F64,)
+    costs: Dict.Dict(position, F64),
-    cameFrom: Dict.Dict(position,position,)
+    cameFrom: Dict.Dict(position, position)
 }
 
 a

crates/compiler/test_syntax/tests/snapshots/pass/comment_after_annotation.expr.migrated.roc

@@ -1,3 +1,3 @@
-F() : e #
+F : e #
 
 q

crates/compiler/test_syntax/tests/snapshots/pass/comment_after_dbg_in_empty_record_assignment.expr.migrated.roc

@@ -1,2 +1,2 @@
-dbg(l,) #
+dbg(l) #
 n

crates/compiler/test_syntax/tests/snapshots/pass/comment_after_whitespace_apply_arg_inside_pnc_apply.expr.migrated.roc

@@ -1,9 +1,9 @@
 PP(P(@P(P(
 P(PPP(P(
-PPP,),
+PPP)
-),
+)
-),
+),
-PP(mport, # <|"P
+PP(mport # <|"P
-),),
+))
-),),
+))
 )

crates/compiler/test_syntax/tests/snapshots/pass/comment_before_comma_in_tuple_type_with_func.expr.migrated.roc

@@ -1,3 +1,3 @@
-1: (M,b, # ,
+1: (M, b, # ,
-    h, -> g,..e)
+    h -> g, ..e)
 h

crates/compiler/test_syntax/tests/snapshots/pass/comment_before_op.expr.migrated.roc

@@ -1,2 +1,2 @@
 3 # test!
-+ 4
+ + 4

crates/compiler/test_syntax/tests/snapshots/pass/comment_in_closure_pat.expr.migrated.roc

@@ -1,2 +1,2 @@
 |L( #
-i,)| -e
+i)| -e

crates/compiler/test_syntax/tests/snapshots/pass/comment_in_closure_pat_apply.expr.migrated.roc

@@ -1,2 +1,2 @@
 |LM( #
-Q,)| f8
+Q)| f8

crates/compiler/test_syntax/tests/snapshots/pass/comment_indent_in_parens.expr.migrated.roc

@@ -1,4 +1,4 @@
-1(0, #
+1(0 #
 #
 ): gi
 M

crates/compiler/test_syntax/tests/snapshots/pass/comment_with_non_ascii.expr.migrated.roc

@@ -1,2 +1,2 @@
 3 # 2 × 2
-+ 4
+ + 4

crates/compiler/test_syntax/tests/snapshots/pass/compare_apply_record.expr.migrated.roc

@@ -1,4 +1,4 @@
 x >
 x({
 
-},) < r
+}) < r

crates/compiler/test_syntax/tests/snapshots/pass/crash.expr.migrated.roc

@@ -1,11 +1,11 @@
-_ = crash("",)
+_ = crash("")
-_ = crash("","",)
+_ = crash("", "")
-_ = crash(15,123,)
+_ = crash(15, 123)
-_ = try(foo,(|_| crash("",)),)
+_ = try(foo, (|_| crash("")))
 _ =
 {
-    _ = crash("",)
+    _ = crash("")
     crash
 }
 
-{f: crash("",)}
+{f: crash("")}

crates/compiler/test_syntax/tests/snapshots/pass/crazy_annotation_left.expr.migrated.roc

@@ -1,4 +1,4 @@
 1(0( #
-0,),
+0)
-)(f,): f
+)(f): f
 t

crates/compiler/test_syntax/tests/snapshots/pass/crazy_annotation_left2.expr.migrated.roc

@@ -1,6 +1,6 @@
-1(ts(0,
+1(ts(0
 
 #
-),
+)
-)(f,): i7f
+)(f): i7f
 e

crates/compiler/test_syntax/tests/snapshots/pass/crazy_parens_multiline_str_question_etc.expr.migrated.roc

@@ -3,4 +3,4 @@
     -
     """
     """()?
-}))(Y,)
+}))(Y)

crates/compiler/test_syntax/tests/snapshots/pass/crazy_pat_ann.expr.migrated.roc

@@ -1,4 +1,4 @@
 0(
 #
-f,): f
+f): f
 t

crates/compiler/test_syntax/tests/snapshots/pass/curried_function_type.expr.migrated.roc

@@ -1,2 +1,2 @@
-1: w, -> w, -> p
+1: w -> w -> p
 h

crates/compiler/test_syntax/tests/snapshots/pass/dbg.expr.migrated.roc

@@ -1 +1 @@
-dbg(1,)
+dbg(1)

crates/compiler/test_syntax/tests/snapshots/pass/dbg_double.expr.migrated.roc

@@ -1 +1 @@
-dbg(dbg,g,g,)
+dbg(dbg, g, g)

crates/compiler/test_syntax/tests/snapshots/pass/dbg_double_newline.expr.migrated.roc

@@ -1,2 +1,2 @@
 dbg(dbg,
-a,g,)
+a, g)

crates/compiler/test_syntax/tests/snapshots/pass/dbg_extra_parens.expr.migrated.roc

@@ -1,2 +1,2 @@
-dbg(d,z,)
+dbg(d, z)
 dd

crates/compiler/test_syntax/tests/snapshots/pass/dbg_newline_apply.expr.migrated.roc

@@ -1,4 +1,4 @@
 dbg(
 
 izzb,
-interfacesb,)
+interfacesb)

crates/compiler/test_syntax/tests/snapshots/pass/dbg_pnc_a_over_a.expr.migrated.roc

@@ -1,2 +1,2 @@
-dbg(a / a,)
+dbg(a / a)
 d

crates/compiler/test_syntax/tests/snapshots/pass/dbg_pnc_in_double_parens.expr.migrated.roc

@@ -1,4 +1,4 @@
 ({
-    (dbg(r,))
+    (dbg(r))
     r
 })

crates/compiler/test_syntax/tests/snapshots/pass/dbg_stmt_multiline.expr.migrated.roc

@@ -1,4 +1,4 @@
 dbg (5,
-    666,)
+    666)
 
 4

crates/compiler/test_syntax/tests/snapshots/pass/dbg_stmt_two_exprs.expr.migrated.roc

@@ -1,6 +1,6 @@
 dbg
 (q(
-qt,))
+qt))
 
 g(
-qt,)
+qt)

crates/compiler/test_syntax/tests/snapshots/pass/def_bang.expr.migrated.roc

@@ -1,4 +1,4 @@
 launchTheNukes! = |{}|
 boom
 
-launchTheNukes!({},)
+launchTheNukes!({})

crates/compiler/test_syntax/tests/snapshots/pass/def_multistring_apply.expr.migrated.roc

@@ -1,4 +1,4 @@
 e =
 """
-"""(a,)
+"""(a)
 p

crates/compiler/test_syntax/tests/snapshots/pass/defs_suffixed_middle_extra_indents.moduledefs.migrated.roc

@@ -1,7 +1,7 @@
 main =
 {
     a = "Foo"
-    Stdout.line?(a,)
+    Stdout.line?(a)
 
     printBar?
 }
@@ -9,5 +9,5 @@ main =
 printBar =
 {
     b = "Bar"
-    Stdout.line(b,)
+    Stdout.line(b)
 }