Merge branch 'main' into store-all-space-between-annotation-body

crates/compiler/fmt/src/expr.rs

@@ -543,7 +543,7 @@ impl<'a> Formattable for Expr<'a> {
     }
 }
 
-fn is_str_multiline(literal: &StrLiteral) -> bool {
+pub fn is_str_multiline(literal: &StrLiteral) -> bool {
     use roc_parse::ast::StrLiteral::*;
 
     match literal {
@@ -671,10 +671,6 @@ fn push_op(buf: &mut Buf, op: BinOp) {
         called_via::BinOp::And => buf.push_str("&&"),
         called_via::BinOp::Or => buf.push_str("||"),
         called_via::BinOp::Pizza => buf.push_str("|>"),
-        called_via::BinOp::Assignment => unreachable!(),
-        called_via::BinOp::IsAliasType => unreachable!(),
-        called_via::BinOp::IsOpaqueType => unreachable!(),
-        called_via::BinOp::Backpassing => unreachable!(),
     }
 }
 
@@ -1708,10 +1704,6 @@ fn sub_expr_requests_parens(expr: &Expr<'_>) -> bool {
                     | BinOp::And
                     | BinOp::Or
                     | BinOp::Pizza => true,
-                    BinOp::Assignment
-                    | BinOp::IsAliasType
-                    | BinOp::IsOpaqueType
-                    | BinOp::Backpassing => false,
                 })
         }
         Expr::If(_, _) => true,

crates/compiler/fmt/src/module.rs

@@ -3,10 +3,8 @@ use std::cmp::max;
 use crate::annotation::{is_collection_multiline, Formattable, Newlines, Parens};
 use crate::collection::{fmt_collection, Braces};
 use crate::expr::fmt_str_literal;
-use crate::spaces::RemoveSpaces;
 use crate::spaces::{fmt_comments_only, fmt_default_spaces, fmt_spaces, NewlineAt, INDENT};
 use crate::Buf;
-use bumpalo::Bump;
 use roc_parse::ast::{Collection, CommentOrNewline, Header, Module, Spaced, Spaces};
 use roc_parse::header::{
     AppHeader, ExposedName, ExposesKeyword, GeneratesKeyword, HostedHeader, ImportsEntry,
@@ -58,12 +56,6 @@ macro_rules! keywords {
                     buf.push_str($name::KEYWORD);
                 }
             }
-
-            impl<'a> RemoveSpaces<'a> for $name {
-                fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-                    *self
-                }
-            }
         )*
     }
 }

crates/compiler/fmt/src/pattern.rs

@@ -1,5 +1,5 @@
 use crate::annotation::{Formattable, Newlines, Parens};
-use crate::expr::{fmt_str_literal, format_sq_literal};
+use crate::expr::{fmt_str_literal, format_sq_literal, is_str_multiline};
 use crate::spaces::{fmt_comments_only, fmt_spaces, NewlineAt, INDENT};
 use crate::Buf;
 use roc_parse::ast::{Base, CommentOrNewline, Pattern, PatternAs};
@@ -48,7 +48,7 @@ impl<'a> Formattable for Pattern<'a> {
                     pattern
                 );
 
-                spaces.iter().any(|s| s.is_comment())
+                spaces.iter().any(|s| s.is_comment()) || pattern.is_multiline()
             }
 
             Pattern::RecordDestructure(fields) => fields.iter().any(|f| f.is_multiline()),
@@ -63,15 +63,17 @@ impl<'a> Formattable for Pattern<'a> {
                     list_rest_spaces.iter().any(|s| s.is_comment()) || pattern_as.is_multiline()
                 }
             },
+            Pattern::StrLiteral(literal) => is_str_multiline(literal),
+            Pattern::Apply(pat, args) => {
+                pat.is_multiline() || args.iter().any(|a| a.is_multiline())
+            }
 
             Pattern::Identifier { .. }
             | Pattern::Tag(_)
             | Pattern::OpaqueRef(_)
-            | Pattern::Apply(_, _)
             | Pattern::NumLiteral(..)
             | Pattern::NonBase10Literal { .. }
             | Pattern::FloatLiteral(..)
-            | Pattern::StrLiteral(_)
             | Pattern::SingleQuote(_)
             | Pattern::Underscore(_)
             | Pattern::Malformed(_)
@@ -100,7 +102,13 @@ impl<'a> Formattable for Pattern<'a> {
                 buf.indent(indent);
                 // Sometimes, an Apply pattern needs parens around it.
                 // In particular when an Apply's argument is itself an Apply (> 0) arguments
-                let parens = !loc_arg_patterns.is_empty() && parens == Parens::InApply;
+                let parens = !loc_arg_patterns.is_empty() && (parens == Parens::InApply);
+
+                let indent_more = if self.is_multiline() {
+                    indent + INDENT
+                } else {
+                    indent
+                };
 
                 if parens {
                     buf.push('(');
@@ -110,7 +118,7 @@ impl<'a> Formattable for Pattern<'a> {
 
                 for loc_arg in loc_arg_patterns.iter() {
                     buf.spaces(1);
-                    loc_arg.format_with_options(buf, Parens::InApply, Newlines::No, indent);
+                    loc_arg.format_with_options(buf, Parens::InApply, Newlines::No, indent_more);
                 }
 
                 if parens {

crates/compiler/fmt/src/spaces.rs

@@ -1,23 +1,5 @@
-use bumpalo::collections::vec::Vec;
 use bumpalo::Bump;
-use roc_module::called_via::{BinOp, UnaryOp};
-use roc_parse::{
-    ast::{
-        AbilityImpls, AbilityMember, AssignedField, Collection, CommentOrNewline, Defs, Expr,
-        Header, Implements, ImplementsAbilities, ImplementsAbility, ImplementsClause, ImportAlias,
-        ImportAsKeyword, ImportExposingKeyword, ImportedModuleName, IngestedFileAnnotation,
-        IngestedFileImport, Module, ModuleImport, ModuleImportParams, OldRecordBuilderField,
-        Pattern, PatternAs, Spaced, Spaces, StrLiteral, StrSegment, Tag, TypeAnnotation, TypeDef,
-        TypeHeader, ValueDef, WhenBranch,
-    },
-    header::{
-        AppHeader, ExposedName, HostedHeader, ImportsEntry, KeywordItem, ModuleHeader, ModuleName,
-        ModuleParams, PackageEntry, PackageHeader, PackageName, PlatformHeader, PlatformRequires,
-        ProvidesTo, To, TypedIdent,
-    },
-    ident::{BadIdent, UppercaseIdent},
-};
-use roc_region::all::{Loc, Position, Region};
+use roc_parse::{ast::CommentOrNewline, remove_spaces::RemoveSpaces};
 
 use crate::{Ast, Buf};
 
@@ -211,20 +193,6 @@ fn fmt_docs(buf: &mut Buf, docs: &str) {
     buf.push_str(docs.trim_end());
 }
 
-/// RemoveSpaces normalizes the ast to something that we _expect_ to be invariant under formatting.
-///
-/// Currently this consists of:
-/// * Removing newlines
-/// * Removing comments
-/// * Removing parens in Exprs
-///
-/// Long term, we actually want this transform to preserve comments (so we can assert they're maintained by formatting)
-/// - but there are currently several bugs where they're _not_ preserved.
-/// TODO: ensure formatting retains comments
-pub trait RemoveSpaces<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self;
-}
-
 impl<'a> RemoveSpaces<'a> for Ast<'a> {
     fn remove_spaces(&self, arena: &'a Bump) -> Self {
         Ast {
@@ -233,834 +201,3 @@ impl<'a> RemoveSpaces<'a> for Ast<'a> {
         }
     }
 }
-
-impl<'a> RemoveSpaces<'a> for Defs<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        let mut defs = self.clone();
-
-        defs.spaces.clear();
-        defs.space_before.clear();
-        defs.space_after.clear();
-
-        for type_def in defs.type_defs.iter_mut() {
-            *type_def = type_def.remove_spaces(arena);
-        }
-
-        for value_def in defs.value_defs.iter_mut() {
-            *value_def = value_def.remove_spaces(arena);
-        }
-
-        for region_def in defs.regions.iter_mut() {
-            *region_def = region_def.remove_spaces(arena);
-        }
-
-        defs
-    }
-}
-
-impl<'a, V: RemoveSpaces<'a>> RemoveSpaces<'a> for Spaces<'a, V> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        Spaces {
-            before: &[],
-            item: self.item.remove_spaces(arena),
-            after: &[],
-        }
-    }
-}
-
-impl<'a, K: RemoveSpaces<'a>, V: RemoveSpaces<'a>> RemoveSpaces<'a> for KeywordItem<'a, K, V> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        KeywordItem {
-            keyword: self.keyword.remove_spaces(arena),
-            item: self.item.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ProvidesTo<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        ProvidesTo {
-            provides_keyword: self.provides_keyword.remove_spaces(arena),
-            entries: self.entries.remove_spaces(arena),
-            types: self.types.remove_spaces(arena),
-            to_keyword: self.to_keyword.remove_spaces(arena),
-            to: self.to.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for Module<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        let header = match &self.header {
-            Header::Module(header) => Header::Module(ModuleHeader {
-                after_keyword: &[],
-                params: header.params.remove_spaces(arena),
-                exposes: header.exposes.remove_spaces(arena),
-                interface_imports: header.interface_imports.remove_spaces(arena),
-            }),
-            Header::App(header) => Header::App(AppHeader {
-                before_provides: &[],
-                provides: header.provides.remove_spaces(arena),
-                before_packages: &[],
-                packages: header.packages.remove_spaces(arena),
-                old_imports: header.old_imports.remove_spaces(arena),
-                old_provides_to_new_package: header
-                    .old_provides_to_new_package
-                    .remove_spaces(arena),
-            }),
-            Header::Package(header) => Header::Package(PackageHeader {
-                before_exposes: &[],
-                exposes: header.exposes.remove_spaces(arena),
-                before_packages: &[],
-                packages: header.packages.remove_spaces(arena),
-            }),
-            Header::Platform(header) => Header::Platform(PlatformHeader {
-                before_name: &[],
-                name: header.name.remove_spaces(arena),
-                requires: header.requires.remove_spaces(arena),
-                exposes: header.exposes.remove_spaces(arena),
-                packages: header.packages.remove_spaces(arena),
-                imports: header.imports.remove_spaces(arena),
-                provides: header.provides.remove_spaces(arena),
-            }),
-            Header::Hosted(header) => Header::Hosted(HostedHeader {
-                before_name: &[],
-                name: header.name.remove_spaces(arena),
-                exposes: header.exposes.remove_spaces(arena),
-                imports: header.imports.remove_spaces(arena),
-                generates: header.generates.remove_spaces(arena),
-                generates_with: header.generates_with.remove_spaces(arena),
-            }),
-        };
-        Module {
-            comments: &[],
-            header,
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ModuleParams<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        ModuleParams {
-            params: self.params.remove_spaces(arena),
-            before_arrow: &[],
-            after_arrow: &[],
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for Region {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        Region::zero()
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for &'a str {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        self
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a> + Copy> RemoveSpaces<'a> for Spaced<'a, T> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            Spaced::Item(a) => Spaced::Item(a.remove_spaces(arena)),
-            Spaced::SpaceBefore(a, _) => a.remove_spaces(arena),
-            Spaced::SpaceAfter(a, _) => a.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ExposedName<'a> {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ModuleName<'a> {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for PackageName<'a> {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for To<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            To::ExistingPackage(a) => To::ExistingPackage(a),
-            To::NewPackage(a) => To::NewPackage(a.remove_spaces(arena)),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for TypedIdent<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        TypedIdent {
-            ident: self.ident.remove_spaces(arena),
-            spaces_before_colon: &[],
-            ann: self.ann.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for PlatformRequires<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        PlatformRequires {
-            rigids: self.rigids.remove_spaces(arena),
-            signature: self.signature.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for UppercaseIdent<'a> {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for PackageEntry<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        PackageEntry {
-            shorthand: self.shorthand,
-            spaces_after_shorthand: &[],
-            platform_marker: match self.platform_marker {
-                Some(_) => Some(&[]),
-                None => None,
-            },
-            package_name: self.package_name.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImportsEntry<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            ImportsEntry::Module(a, b) => ImportsEntry::Module(a, b.remove_spaces(arena)),
-            ImportsEntry::Package(a, b, c) => ImportsEntry::Package(a, b, c.remove_spaces(arena)),
-            ImportsEntry::IngestedFile(a, b) => {
-                ImportsEntry::IngestedFile(a, b.remove_spaces(arena))
-            }
-        }
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a>> RemoveSpaces<'a> for Option<T> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        self.as_ref().map(|a| a.remove_spaces(arena))
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a> + std::fmt::Debug> RemoveSpaces<'a> for Loc<T> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        let res = self.value.remove_spaces(arena);
-        Loc::at(Region::zero(), res)
-    }
-}
-
-impl<'a, A: RemoveSpaces<'a>, B: RemoveSpaces<'a>> RemoveSpaces<'a> for (A, B) {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        (self.0.remove_spaces(arena), self.1.remove_spaces(arena))
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a>> RemoveSpaces<'a> for Collection<'a, T> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        let mut items = Vec::with_capacity_in(self.items.len(), arena);
-        for item in self.items {
-            items.push(item.remove_spaces(arena));
-        }
-        Collection::with_items(items.into_bump_slice())
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a> + std::fmt::Debug> RemoveSpaces<'a> for &'a [T] {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        let mut items = Vec::with_capacity_in(self.len(), arena);
-        for item in *self {
-            let res = item.remove_spaces(arena);
-            items.push(res);
-        }
-        items.into_bump_slice()
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for UnaryOp {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for BinOp {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a>> RemoveSpaces<'a> for &'a T {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        arena.alloc((*self).remove_spaces(arena))
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for TypeDef<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        use TypeDef::*;
-
-        match *self {
-            Alias {
-                header: TypeHeader { name, vars },
-                ann,
-            } => Alias {
-                header: TypeHeader {
-                    name: name.remove_spaces(arena),
-                    vars: vars.remove_spaces(arena),
-                },
-                ann: ann.remove_spaces(arena),
-            },
-            Opaque {
-                header: TypeHeader { name, vars },
-                typ,
-                derived,
-            } => Opaque {
-                header: TypeHeader {
-                    name: name.remove_spaces(arena),
-                    vars: vars.remove_spaces(arena),
-                },
-                typ: typ.remove_spaces(arena),
-                derived: derived.remove_spaces(arena),
-            },
-            Ability {
-                header: TypeHeader { name, vars },
-                loc_implements: loc_has,
-                members,
-            } => Ability {
-                header: TypeHeader {
-                    name: name.remove_spaces(arena),
-                    vars: vars.remove_spaces(arena),
-                },
-                loc_implements: loc_has.remove_spaces(arena),
-                members: members.remove_spaces(arena),
-            },
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ValueDef<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        use ValueDef::*;
-
-        match *self {
-            Annotation(a, b) => Annotation(a.remove_spaces(arena), b.remove_spaces(arena)),
-            Body(a, b) => Body(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-            ),
-            AnnotatedBody {
-                ann_pattern,
-                ann_type,
-                comment: _,
-                body_pattern,
-                body_expr,
-            } => AnnotatedBody {
-                ann_pattern: arena.alloc(ann_pattern.remove_spaces(arena)),
-                ann_type: arena.alloc(ann_type.remove_spaces(arena)),
-                comment: &[],
-                body_pattern: arena.alloc(body_pattern.remove_spaces(arena)),
-                body_expr: arena.alloc(body_expr.remove_spaces(arena)),
-            },
-            Dbg {
-                condition,
-                preceding_comment: _,
-            } => Dbg {
-                condition: arena.alloc(condition.remove_spaces(arena)),
-                preceding_comment: Region::zero(),
-            },
-            Expect {
-                condition,
-                preceding_comment: _,
-            } => Expect {
-                condition: arena.alloc(condition.remove_spaces(arena)),
-                preceding_comment: Region::zero(),
-            },
-            ExpectFx {
-                condition,
-                preceding_comment: _,
-            } => ExpectFx {
-                condition: arena.alloc(condition.remove_spaces(arena)),
-                preceding_comment: Region::zero(),
-            },
-            ModuleImport(module_import) => ModuleImport(module_import.remove_spaces(arena)),
-            IngestedFileImport(ingested_file_import) => {
-                IngestedFileImport(ingested_file_import.remove_spaces(arena))
-            }
-            Stmt(loc_expr) => Stmt(arena.alloc(loc_expr.remove_spaces(arena))),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ModuleImport<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        ModuleImport {
-            before_name: &[],
-            name: self.name.remove_spaces(arena),
-            params: self.params.remove_spaces(arena),
-            alias: self.alias.remove_spaces(arena),
-            exposed: self.exposed.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ModuleImportParams<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        ModuleImportParams {
-            before: &[],
-            params: self.params.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for IngestedFileImport<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        IngestedFileImport {
-            before_path: &[],
-            path: self.path.remove_spaces(arena),
-            name: self.name.remove_spaces(arena),
-            annotation: self.annotation.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImportedModuleName<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        ImportedModuleName {
-            package: self.package.remove_spaces(arena),
-            name: self.name.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImportAlias<'a> {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImportAsKeyword {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImportExposingKeyword {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        *self
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for IngestedFileAnnotation<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        IngestedFileAnnotation {
-            before_colon: &[],
-            annotation: self.annotation.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for Implements<'a> {
-    fn remove_spaces(&self, _arena: &'a Bump) -> Self {
-        Implements::Implements
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for AbilityMember<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        AbilityMember {
-            name: self.name.remove_spaces(arena),
-            typ: self.typ.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for WhenBranch<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        WhenBranch {
-            patterns: self.patterns.remove_spaces(arena),
-            value: self.value.remove_spaces(arena),
-            guard: self.guard.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a, T: RemoveSpaces<'a> + Copy + std::fmt::Debug> RemoveSpaces<'a> for AssignedField<'a, T> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            AssignedField::RequiredValue(a, _, c) => AssignedField::RequiredValue(
-                a.remove_spaces(arena),
-                arena.alloc([]),
-                arena.alloc(c.remove_spaces(arena)),
-            ),
-            AssignedField::OptionalValue(a, _, c) => AssignedField::OptionalValue(
-                a.remove_spaces(arena),
-                arena.alloc([]),
-                arena.alloc(c.remove_spaces(arena)),
-            ),
-            AssignedField::LabelOnly(a) => AssignedField::LabelOnly(a.remove_spaces(arena)),
-            AssignedField::Malformed(a) => AssignedField::Malformed(a),
-            AssignedField::SpaceBefore(a, _) => a.remove_spaces(arena),
-            AssignedField::SpaceAfter(a, _) => a.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for OldRecordBuilderField<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            OldRecordBuilderField::Value(a, _, c) => OldRecordBuilderField::Value(
-                a.remove_spaces(arena),
-                &[],
-                arena.alloc(c.remove_spaces(arena)),
-            ),
-            OldRecordBuilderField::ApplyValue(a, _, _, c) => OldRecordBuilderField::ApplyValue(
-                a.remove_spaces(arena),
-                &[],
-                &[],
-                arena.alloc(c.remove_spaces(arena)),
-            ),
-            OldRecordBuilderField::LabelOnly(a) => {
-                OldRecordBuilderField::LabelOnly(a.remove_spaces(arena))
-            }
-            OldRecordBuilderField::Malformed(a) => OldRecordBuilderField::Malformed(a),
-            OldRecordBuilderField::SpaceBefore(a, _) => a.remove_spaces(arena),
-            OldRecordBuilderField::SpaceAfter(a, _) => a.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for StrLiteral<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            StrLiteral::PlainLine(t) => StrLiteral::PlainLine(t),
-            StrLiteral::Line(t) => StrLiteral::Line(t.remove_spaces(arena)),
-            StrLiteral::Block(t) => StrLiteral::Block(t.remove_spaces(arena)),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for StrSegment<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            StrSegment::Plaintext(t) => StrSegment::Plaintext(t),
-            StrSegment::Unicode(t) => StrSegment::Unicode(t.remove_spaces(arena)),
-            StrSegment::EscapedChar(c) => StrSegment::EscapedChar(c),
-            StrSegment::Interpolated(t) => StrSegment::Interpolated(t.remove_spaces(arena)),
-            StrSegment::DeprecatedInterpolated(t) => {
-                StrSegment::DeprecatedInterpolated(t.remove_spaces(arena))
-            }
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for Expr<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            Expr::Float(a) => Expr::Float(a),
-            Expr::Num(a) => Expr::Num(a),
-            Expr::NonBase10Int {
-                string,
-                base,
-                is_negative,
-            } => Expr::NonBase10Int {
-                string,
-                base,
-                is_negative,
-            },
-            Expr::Str(a) => Expr::Str(a.remove_spaces(arena)),
-            Expr::RecordAccess(a, b) => Expr::RecordAccess(arena.alloc(a.remove_spaces(arena)), b),
-            Expr::AccessorFunction(a) => Expr::AccessorFunction(a),
-            Expr::TupleAccess(a, b) => Expr::TupleAccess(arena.alloc(a.remove_spaces(arena)), b),
-            Expr::TaskAwaitBang(a) => Expr::TaskAwaitBang(arena.alloc(a.remove_spaces(arena))),
-            Expr::List(a) => Expr::List(a.remove_spaces(arena)),
-            Expr::RecordUpdate { update, fields } => Expr::RecordUpdate {
-                update: arena.alloc(update.remove_spaces(arena)),
-                fields: fields.remove_spaces(arena),
-            },
-            Expr::Record(a) => Expr::Record(a.remove_spaces(arena)),
-            Expr::OldRecordBuilder(a) => Expr::OldRecordBuilder(a.remove_spaces(arena)),
-            Expr::RecordBuilder { mapper, fields } => Expr::RecordBuilder {
-                mapper: arena.alloc(mapper.remove_spaces(arena)),
-                fields: fields.remove_spaces(arena),
-            },
-            Expr::Tuple(a) => Expr::Tuple(a.remove_spaces(arena)),
-            Expr::Var { module_name, ident } => Expr::Var { module_name, ident },
-            Expr::Underscore(a) => Expr::Underscore(a),
-            Expr::Tag(a) => Expr::Tag(a),
-            Expr::OpaqueRef(a) => Expr::OpaqueRef(a),
-            Expr::Closure(a, b) => Expr::Closure(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-            ),
-            Expr::Crash => Expr::Crash,
-            Expr::Defs(a, b) => {
-                let mut defs = a.clone();
-                defs.space_before = vec![Default::default(); defs.len()];
-                defs.space_after = vec![Default::default(); defs.len()];
-                defs.regions = vec![Region::zero(); defs.len()];
-                defs.spaces.clear();
-
-                for type_def in defs.type_defs.iter_mut() {
-                    *type_def = type_def.remove_spaces(arena);
-                }
-
-                for value_def in defs.value_defs.iter_mut() {
-                    *value_def = value_def.remove_spaces(arena);
-                }
-
-                Expr::Defs(arena.alloc(defs), arena.alloc(b.remove_spaces(arena)))
-            }
-            Expr::Backpassing(a, b, c) => Expr::Backpassing(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-                arena.alloc(c.remove_spaces(arena)),
-            ),
-            Expr::Expect(a, b) => Expr::Expect(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-            ),
-            Expr::Dbg(a, b) => Expr::Dbg(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-            ),
-            Expr::LowLevelDbg(_, _, _) => unreachable!(
-                "LowLevelDbg should only exist after desugaring, not during formatting"
-            ),
-            Expr::Apply(a, b, c) => Expr::Apply(
-                arena.alloc(a.remove_spaces(arena)),
-                b.remove_spaces(arena),
-                c,
-            ),
-            Expr::BinOps(a, b) => {
-                Expr::BinOps(a.remove_spaces(arena), arena.alloc(b.remove_spaces(arena)))
-            }
-            Expr::UnaryOp(a, b) => {
-                Expr::UnaryOp(arena.alloc(a.remove_spaces(arena)), b.remove_spaces(arena))
-            }
-            Expr::If(a, b) => Expr::If(a.remove_spaces(arena), arena.alloc(b.remove_spaces(arena))),
-            Expr::When(a, b) => {
-                Expr::When(arena.alloc(a.remove_spaces(arena)), b.remove_spaces(arena))
-            }
-            Expr::ParensAround(a) => {
-                // The formatter can remove redundant parentheses, so also remove these when normalizing for comparison.
-                a.remove_spaces(arena)
-            }
-            Expr::MalformedIdent(a, b) => Expr::MalformedIdent(a, remove_spaces_bad_ident(b)),
-            Expr::MalformedClosure => Expr::MalformedClosure,
-            Expr::MalformedSuffixed(a) => Expr::MalformedSuffixed(a),
-            Expr::PrecedenceConflict(a) => Expr::PrecedenceConflict(a),
-            Expr::MultipleOldRecordBuilders(a) => Expr::MultipleOldRecordBuilders(a),
-            Expr::UnappliedOldRecordBuilder(a) => Expr::UnappliedOldRecordBuilder(a),
-            Expr::EmptyRecordBuilder(a) => Expr::EmptyRecordBuilder(a),
-            Expr::SingleFieldRecordBuilder(a) => Expr::SingleFieldRecordBuilder(a),
-            Expr::OptionalFieldInRecordBuilder(name, a) => {
-                Expr::OptionalFieldInRecordBuilder(name, a)
-            }
-            Expr::SpaceBefore(a, _) => a.remove_spaces(arena),
-            Expr::SpaceAfter(a, _) => a.remove_spaces(arena),
-            Expr::SingleQuote(a) => Expr::Num(a),
-        }
-    }
-}
-
-fn remove_spaces_bad_ident(ident: BadIdent) -> BadIdent {
-    match ident {
-        BadIdent::Start(_) => BadIdent::Start(Position::zero()),
-        BadIdent::Space(e, _) => BadIdent::Space(e, Position::zero()),
-        BadIdent::UnderscoreAlone(_) => BadIdent::UnderscoreAlone(Position::zero()),
-        BadIdent::UnderscoreInMiddle(_) => BadIdent::UnderscoreInMiddle(Position::zero()),
-        BadIdent::UnderscoreAtStart {
-            position: _,
-            declaration_region,
-        } => BadIdent::UnderscoreAtStart {
-            position: Position::zero(),
-            declaration_region,
-        },
-        BadIdent::QualifiedTag(_) => BadIdent::QualifiedTag(Position::zero()),
-        BadIdent::WeirdAccessor(_) => BadIdent::WeirdAccessor(Position::zero()),
-        BadIdent::WeirdDotAccess(_) => BadIdent::WeirdDotAccess(Position::zero()),
-        BadIdent::WeirdDotQualified(_) => BadIdent::WeirdDotQualified(Position::zero()),
-        BadIdent::StrayDot(_) => BadIdent::StrayDot(Position::zero()),
-        BadIdent::BadOpaqueRef(_) => BadIdent::BadOpaqueRef(Position::zero()),
-        BadIdent::QualifiedTupleAccessor(_) => BadIdent::QualifiedTupleAccessor(Position::zero()),
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for Pattern<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            Pattern::Identifier { ident } => Pattern::Identifier { ident },
-            Pattern::Tag(a) => Pattern::Tag(a),
-            Pattern::OpaqueRef(a) => Pattern::OpaqueRef(a),
-            Pattern::Apply(a, b) => Pattern::Apply(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-            ),
-            Pattern::RecordDestructure(a) => Pattern::RecordDestructure(a.remove_spaces(arena)),
-            Pattern::RequiredField(a, b) => {
-                Pattern::RequiredField(a, arena.alloc(b.remove_spaces(arena)))
-            }
-            Pattern::OptionalField(a, b) => {
-                Pattern::OptionalField(a, arena.alloc(b.remove_spaces(arena)))
-            }
-            Pattern::As(pattern, pattern_as) => Pattern::As(
-                arena.alloc(pattern.remove_spaces(arena)),
-                pattern_as.remove_spaces(arena),
-            ),
-            Pattern::NumLiteral(a) => Pattern::NumLiteral(a),
-            Pattern::NonBase10Literal {
-                string,
-                base,
-                is_negative,
-            } => Pattern::NonBase10Literal {
-                string,
-                base,
-                is_negative,
-            },
-            Pattern::FloatLiteral(a) => Pattern::FloatLiteral(a),
-            Pattern::StrLiteral(a) => Pattern::StrLiteral(a),
-            Pattern::Underscore(a) => Pattern::Underscore(a),
-            Pattern::Malformed(a) => Pattern::Malformed(a),
-            Pattern::MalformedIdent(a, b) => Pattern::MalformedIdent(a, remove_spaces_bad_ident(b)),
-            Pattern::QualifiedIdentifier { module_name, ident } => {
-                Pattern::QualifiedIdentifier { module_name, ident }
-            }
-            Pattern::SpaceBefore(a, _) => a.remove_spaces(arena),
-            Pattern::SpaceAfter(a, _) => a.remove_spaces(arena),
-            Pattern::SingleQuote(a) => Pattern::SingleQuote(a),
-            Pattern::List(pats) => Pattern::List(pats.remove_spaces(arena)),
-            Pattern::Tuple(pats) => Pattern::Tuple(pats.remove_spaces(arena)),
-            Pattern::ListRest(opt_pattern_as) => Pattern::ListRest(
-                opt_pattern_as
-                    .map(|(_, pattern_as)| ([].as_ref(), pattern_as.remove_spaces(arena))),
-            ),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for TypeAnnotation<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            TypeAnnotation::Function(a, b) => TypeAnnotation::Function(
-                arena.alloc(a.remove_spaces(arena)),
-                arena.alloc(b.remove_spaces(arena)),
-            ),
-            TypeAnnotation::Apply(a, b, c) => TypeAnnotation::Apply(a, b, c.remove_spaces(arena)),
-            TypeAnnotation::BoundVariable(a) => TypeAnnotation::BoundVariable(a),
-            TypeAnnotation::As(a, _, TypeHeader { name, vars }) => TypeAnnotation::As(
-                arena.alloc(a.remove_spaces(arena)),
-                &[],
-                TypeHeader {
-                    name: name.remove_spaces(arena),
-                    vars: vars.remove_spaces(arena),
-                },
-            ),
-            TypeAnnotation::Tuple { elems: fields, ext } => TypeAnnotation::Tuple {
-                elems: fields.remove_spaces(arena),
-                ext: ext.remove_spaces(arena),
-            },
-            TypeAnnotation::Record { fields, ext } => TypeAnnotation::Record {
-                fields: fields.remove_spaces(arena),
-                ext: ext.remove_spaces(arena),
-            },
-            TypeAnnotation::TagUnion { ext, tags } => TypeAnnotation::TagUnion {
-                ext: ext.remove_spaces(arena),
-                tags: tags.remove_spaces(arena),
-            },
-            TypeAnnotation::Inferred => TypeAnnotation::Inferred,
-            TypeAnnotation::Wildcard => TypeAnnotation::Wildcard,
-            TypeAnnotation::Where(annot, has_clauses) => TypeAnnotation::Where(
-                arena.alloc(annot.remove_spaces(arena)),
-                arena.alloc(has_clauses.remove_spaces(arena)),
-            ),
-            TypeAnnotation::SpaceBefore(a, _) => a.remove_spaces(arena),
-            TypeAnnotation::SpaceAfter(a, _) => a.remove_spaces(arena),
-            TypeAnnotation::Malformed(a) => TypeAnnotation::Malformed(a),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImplementsClause<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        ImplementsClause {
-            var: self.var.remove_spaces(arena),
-            abilities: self.abilities.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for Tag<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            Tag::Apply { name, args } => Tag::Apply {
-                name: name.remove_spaces(arena),
-                args: args.remove_spaces(arena),
-            },
-            Tag::Malformed(a) => Tag::Malformed(a),
-            Tag::SpaceBefore(a, _) => a.remove_spaces(arena),
-            Tag::SpaceAfter(a, _) => a.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for AbilityImpls<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            AbilityImpls::AbilityImpls(impls) => {
-                AbilityImpls::AbilityImpls(impls.remove_spaces(arena))
-            }
-            AbilityImpls::SpaceBefore(has, _) | AbilityImpls::SpaceAfter(has, _) => {
-                has.remove_spaces(arena)
-            }
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImplementsAbility<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            ImplementsAbility::ImplementsAbility { ability, impls } => {
-                ImplementsAbility::ImplementsAbility {
-                    ability: ability.remove_spaces(arena),
-                    impls: impls.remove_spaces(arena),
-                }
-            }
-            ImplementsAbility::SpaceBefore(has, _) | ImplementsAbility::SpaceAfter(has, _) => {
-                has.remove_spaces(arena)
-            }
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for ImplementsAbilities<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        match *self {
-            ImplementsAbilities::Implements(derived) => {
-                ImplementsAbilities::Implements(derived.remove_spaces(arena))
-            }
-            ImplementsAbilities::SpaceBefore(derived, _)
-            | ImplementsAbilities::SpaceAfter(derived, _) => derived.remove_spaces(arena),
-        }
-    }
-}
-
-impl<'a> RemoveSpaces<'a> for PatternAs<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        PatternAs {
-            spaces_before: &[],
-            identifier: self.identifier.remove_spaces(arena),
-        }
-    }
-}