diff --git a/crates/cli/src/format.rs b/crates/cli/src/format.rs index c31958de65..6cd649a5ee 100644 --- a/crates/cli/src/format.rs +++ b/crates/cli/src/format.rs @@ -9,7 +9,7 @@ use roc_fmt::header::fmt_header; use roc_fmt::Buf; use roc_parse::ast::{FullAst, SpacesBefore}; use roc_parse::header::parse_module_defs; -use roc_parse::remove_spaces::RemoveSpaces; +use roc_parse::normalize::Normalize; use roc_parse::{header, parser::SyntaxError, state::State}; #[derive(Copy, Clone, Debug)] @@ -200,8 +200,8 @@ pub fn format_src(arena: &Bump, src: &str) -> Result { } }; - let ast_normalized = ast.remove_spaces(arena); - let reparsed_ast_normalized = reparsed_ast.remove_spaces(arena); + let ast_normalized = ast.normalize(arena); + let reparsed_ast_normalized = reparsed_ast.normalize(arena); // HACK! // We compare the debug format strings of the ASTs, because I'm finding in practice that _somewhere_ deep inside the ast, diff --git a/crates/compiler/parse/src/lib.rs b/crates/compiler/parse/src/lib.rs index 9651baf403..f92899aa89 100644 --- a/crates/compiler/parse/src/lib.rs +++ b/crates/compiler/parse/src/lib.rs @@ -13,10 +13,10 @@ pub mod header; pub mod highlight; pub mod ident; pub mod keyword; +pub mod normalize; pub mod number_literal; pub mod pattern; pub mod problems; -pub mod remove_spaces; pub mod src64; pub mod state; pub mod string_literal; diff --git a/crates/compiler/parse/src/remove_spaces.rs b/crates/compiler/parse/src/normalize.rs similarity index 63% rename from crates/compiler/parse/src/remove_spaces.rs rename to crates/compiler/parse/src/normalize.rs index 66e45e3cfd..84ac34304a 100644 --- a/crates/compiler/parse/src/remove_spaces.rs +++ b/crates/compiler/parse/src/normalize.rs @@ -29,25 +29,26 @@ use crate::{ }, }; -/// RemoveSpaces normalizes the ast to something that we _expect_ to be invariant under formatting. +/// 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 +/// * Normalizing string encoding /// /// 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; +pub trait Normalize<'a> { + fn normalize(&self, arena: &'a Bump) -> Self; } macro_rules! keywords { ($($name:ident),* $(,)?) => { $( - impl<'a> RemoveSpaces<'a> for $name { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { + impl<'a> Normalize<'a> for $name { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } @@ -68,8 +69,8 @@ keywords! { PlatformKeyword, } -impl<'a> RemoveSpaces<'a> for Defs<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Defs<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { let mut defs = self.clone(); defs.spaces.clear(); @@ -77,202 +78,200 @@ impl<'a> RemoveSpaces<'a> for Defs<'a> { defs.space_after.clear(); for type_def in defs.type_defs.iter_mut() { - *type_def = type_def.remove_spaces(arena); + *type_def = type_def.normalize(arena); } for value_def in defs.value_defs.iter_mut() { - *value_def = value_def.remove_spaces(arena); + *value_def = value_def.normalize(arena); } for region_def in defs.regions.iter_mut() { - *region_def = region_def.remove_spaces(arena); + *region_def = region_def.normalize(arena); } defs } } -impl<'a, V: RemoveSpaces<'a>> RemoveSpaces<'a> for Spaces<'a, V> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a, V: Normalize<'a>> Normalize<'a> for Spaces<'a, V> { + fn normalize(&self, arena: &'a Bump) -> Self { Spaces { before: &[], - item: self.item.remove_spaces(arena), + item: self.item.normalize(arena), after: &[], } } } -impl<'a, V: RemoveSpaces<'a>> RemoveSpaces<'a> for SpacesBefore<'a, V> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a, V: Normalize<'a>> Normalize<'a> for SpacesBefore<'a, V> { + fn normalize(&self, arena: &'a Bump) -> Self { SpacesBefore { before: &[], - item: self.item.remove_spaces(arena), + item: self.item.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for FullAst<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for FullAst<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { FullAst { - header: self.header.remove_spaces(arena), - defs: self.defs.remove_spaces(arena), + header: self.header.normalize(arena), + defs: self.defs.normalize(arena), } } } -impl<'a, K: RemoveSpaces<'a>, V: RemoveSpaces<'a>> RemoveSpaces<'a> for KeywordItem<'a, K, V> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a, K: Normalize<'a>, V: Normalize<'a>> Normalize<'a> for KeywordItem<'a, K, V> { + fn normalize(&self, arena: &'a Bump) -> Self { KeywordItem { - keyword: self.keyword.remove_spaces(arena), - item: self.item.remove_spaces(arena), + keyword: self.keyword.normalize(arena), + item: self.item.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for ProvidesTo<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ProvidesTo<'a> { + fn normalize(&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), + provides_keyword: self.provides_keyword.normalize(arena), + entries: self.entries.normalize(arena), + types: self.types.normalize(arena), + to_keyword: self.to_keyword.normalize(arena), + to: self.to.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for Header<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Header<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { 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), + params: header.params.normalize(arena), + exposes: header.exposes.normalize(arena), + interface_imports: header.interface_imports.normalize(arena), }), Header::App(header) => Header::App(AppHeader { before_provides: &[], - provides: header.provides.remove_spaces(arena), + provides: header.provides.normalize(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), + packages: header.packages.normalize(arena), + old_imports: header.old_imports.normalize(arena), + old_provides_to_new_package: header.old_provides_to_new_package.normalize(arena), }), Header::Package(header) => Header::Package(PackageHeader { before_exposes: &[], - exposes: header.exposes.remove_spaces(arena), + exposes: header.exposes.normalize(arena), before_packages: &[], - packages: header.packages.remove_spaces(arena), + packages: header.packages.normalize(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), + name: header.name.normalize(arena), + requires: header.requires.normalize(arena), + exposes: header.exposes.normalize(arena), + packages: header.packages.normalize(arena), + imports: header.imports.normalize(arena), + provides: header.provides.normalize(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), + name: header.name.normalize(arena), + exposes: header.exposes.normalize(arena), + imports: header.imports.normalize(arena), + generates: header.generates.normalize(arena), + generates_with: header.generates_with.normalize(arena), }), } } } -impl<'a> RemoveSpaces<'a> for ModuleParams<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ModuleParams<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { ModuleParams { - params: self.params.remove_spaces(arena), + params: self.params.normalize(arena), before_arrow: &[], after_arrow: &[], } } } -impl<'a> RemoveSpaces<'a> for Region { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Region { + fn normalize(&self, _arena: &'a Bump) -> Self { Region::zero() } } -impl<'a> RemoveSpaces<'a> for &'a str { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for &'a str { + fn normalize(&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 { +impl<'a, T: Normalize<'a> + Copy> Normalize<'a> for Spaced<'a, T> { + fn normalize(&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), + Spaced::Item(a) => Spaced::Item(a.normalize(arena)), + Spaced::SpaceBefore(a, _) => a.normalize(arena), + Spaced::SpaceAfter(a, _) => a.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for ExposedName<'a> { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ExposedName<'a> { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for ModuleName<'a> { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ModuleName<'a> { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for PackageName<'a> { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PackageName<'a> { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for To<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for To<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { To::ExistingPackage(a) => To::ExistingPackage(a), - To::NewPackage(a) => To::NewPackage(a.remove_spaces(arena)), + To::NewPackage(a) => To::NewPackage(a.normalize(arena)), } } } -impl<'a> RemoveSpaces<'a> for TypedIdent<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for TypedIdent<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { TypedIdent { - ident: self.ident.remove_spaces(arena), + ident: self.ident.normalize(arena), spaces_before_colon: &[], - ann: self.ann.remove_spaces(arena), + ann: self.ann.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for PlatformRequires<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PlatformRequires<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { PlatformRequires { - rigids: self.rigids.remove_spaces(arena), - signature: self.signature.remove_spaces(arena), + rigids: self.rigids.normalize(arena), + signature: self.signature.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for UppercaseIdent<'a> { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for UppercaseIdent<'a> { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for PackageEntry<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PackageEntry<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { PackageEntry { shorthand: self.shorthand, spaces_after_shorthand: &[], @@ -280,83 +279,81 @@ impl<'a> RemoveSpaces<'a> for PackageEntry<'a> { Some(_) => Some(&[]), None => None, }, - package_name: self.package_name.remove_spaces(arena), + package_name: self.package_name.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for ImportsEntry<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImportsEntry<'a> { + fn normalize(&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)) - } + ImportsEntry::Module(a, b) => ImportsEntry::Module(a, b.normalize(arena)), + ImportsEntry::Package(a, b, c) => ImportsEntry::Package(a, b, c.normalize(arena)), + ImportsEntry::IngestedFile(a, b) => ImportsEntry::IngestedFile(a, b.normalize(arena)), } } } -impl<'a, T: RemoveSpaces<'a>> RemoveSpaces<'a> for Option { - fn remove_spaces(&self, arena: &'a Bump) -> Self { - self.as_ref().map(|a| a.remove_spaces(arena)) +impl<'a, T: Normalize<'a>> Normalize<'a> for Option { + fn normalize(&self, arena: &'a Bump) -> Self { + self.as_ref().map(|a| a.normalize(arena)) } } -impl<'a, T: RemoveSpaces<'a> + std::fmt::Debug> RemoveSpaces<'a> for Loc { - fn remove_spaces(&self, arena: &'a Bump) -> Self { - let res = self.value.remove_spaces(arena); +impl<'a, T: Normalize<'a> + std::fmt::Debug> Normalize<'a> for Loc { + fn normalize(&self, arena: &'a Bump) -> Self { + let res = self.value.normalize(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, A: Normalize<'a>, B: Normalize<'a>> Normalize<'a> for (A, B) { + fn normalize(&self, arena: &'a Bump) -> Self { + (self.0.normalize(arena), self.1.normalize(arena)) } } -impl<'a, T: RemoveSpaces<'a>> RemoveSpaces<'a> for Collection<'a, T> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a, T: Normalize<'a>> Normalize<'a> for Collection<'a, T> { + fn normalize(&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)); + items.push(item.normalize(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 { +impl<'a, T: Normalize<'a> + std::fmt::Debug> Normalize<'a> for &'a [T] { + fn normalize(&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); + let res = item.normalize(arena); items.push(res); } items.into_bump_slice() } } -impl<'a> RemoveSpaces<'a> for UnaryOp { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for UnaryOp { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for BinOp { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for BinOp { + fn normalize(&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, T: Normalize<'a>> Normalize<'a> for &'a T { + fn normalize(&self, arena: &'a Bump) -> Self { + arena.alloc((*self).normalize(arena)) } } -impl<'a> RemoveSpaces<'a> for TypeDef<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for TypeDef<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { use TypeDef::*; match *self { @@ -365,10 +362,10 @@ impl<'a> RemoveSpaces<'a> for TypeDef<'a> { ann, } => Alias { header: TypeHeader { - name: name.remove_spaces(arena), - vars: vars.remove_spaces(arena), + name: name.normalize(arena), + vars: vars.normalize(arena), }, - ann: ann.remove_spaces(arena), + ann: ann.normalize(arena), }, Opaque { header: TypeHeader { name, vars }, @@ -376,11 +373,11 @@ impl<'a> RemoveSpaces<'a> for TypeDef<'a> { derived, } => Opaque { header: TypeHeader { - name: name.remove_spaces(arena), - vars: vars.remove_spaces(arena), + name: name.normalize(arena), + vars: vars.normalize(arena), }, - typ: typ.remove_spaces(arena), - derived: derived.remove_spaces(arena), + typ: typ.normalize(arena), + derived: derived.normalize(arena), }, Ability { header: TypeHeader { name, vars }, @@ -388,25 +385,25 @@ impl<'a> RemoveSpaces<'a> for TypeDef<'a> { members, } => Ability { header: TypeHeader { - name: name.remove_spaces(arena), - vars: vars.remove_spaces(arena), + name: name.normalize(arena), + vars: vars.normalize(arena), }, - loc_implements: loc_has.remove_spaces(arena), - members: members.remove_spaces(arena), + loc_implements: loc_has.normalize(arena), + members: members.normalize(arena), }, } } } -impl<'a> RemoveSpaces<'a> for ValueDef<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ValueDef<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { use ValueDef::*; match *self { - Annotation(a, b) => Annotation(a.remove_spaces(arena), b.remove_spaces(arena)), + Annotation(a, b) => Annotation(a.normalize(arena), b.normalize(arena)), Body(a, b) => Body( - arena.alloc(a.remove_spaces(arena)), - arena.alloc(b.remove_spaces(arena)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), AnnotatedBody { ann_pattern, @@ -415,187 +412,187 @@ impl<'a> RemoveSpaces<'a> for ValueDef<'a> { body_pattern, body_expr, } => AnnotatedBody { - ann_pattern: arena.alloc(ann_pattern.remove_spaces(arena)), - ann_type: arena.alloc(ann_type.remove_spaces(arena)), + ann_pattern: arena.alloc(ann_pattern.normalize(arena)), + ann_type: arena.alloc(ann_type.normalize(arena)), lines_between: &[], - body_pattern: arena.alloc(body_pattern.remove_spaces(arena)), - body_expr: arena.alloc(body_expr.remove_spaces(arena)), + body_pattern: arena.alloc(body_pattern.normalize(arena)), + body_expr: arena.alloc(body_expr.normalize(arena)), }, Dbg { condition, preceding_comment: _, } => Dbg { - condition: arena.alloc(condition.remove_spaces(arena)), + condition: arena.alloc(condition.normalize(arena)), preceding_comment: Region::zero(), }, Expect { condition, preceding_comment: _, } => Expect { - condition: arena.alloc(condition.remove_spaces(arena)), + condition: arena.alloc(condition.normalize(arena)), preceding_comment: Region::zero(), }, ExpectFx { condition, preceding_comment: _, } => ExpectFx { - condition: arena.alloc(condition.remove_spaces(arena)), + condition: arena.alloc(condition.normalize(arena)), preceding_comment: Region::zero(), }, - ModuleImport(module_import) => ModuleImport(module_import.remove_spaces(arena)), + ModuleImport(module_import) => ModuleImport(module_import.normalize(arena)), IngestedFileImport(ingested_file_import) => { - IngestedFileImport(ingested_file_import.remove_spaces(arena)) + IngestedFileImport(ingested_file_import.normalize(arena)) } - Stmt(loc_expr) => Stmt(arena.alloc(loc_expr.remove_spaces(arena))), + Stmt(loc_expr) => Stmt(arena.alloc(loc_expr.normalize(arena))), } } } -impl<'a> RemoveSpaces<'a> for ModuleImport<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ModuleImport<'a> { + fn normalize(&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), + name: self.name.normalize(arena), + params: self.params.normalize(arena), + alias: self.alias.normalize(arena), + exposed: self.exposed.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for ModuleImportParams<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ModuleImportParams<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { ModuleImportParams { before: &[], - params: self.params.remove_spaces(arena), + params: self.params.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for IngestedFileImport<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for IngestedFileImport<'a> { + fn normalize(&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), + path: self.path.normalize(arena), + name: self.name.normalize(arena), + annotation: self.annotation.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for ImportedModuleName<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImportedModuleName<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { ImportedModuleName { - package: self.package.remove_spaces(arena), - name: self.name.remove_spaces(arena), + package: self.package.normalize(arena), + name: self.name.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for ImportAlias<'a> { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImportAlias<'a> { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for ImportAsKeyword { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImportAsKeyword { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for ImportExposingKeyword { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImportExposingKeyword { + fn normalize(&self, _arena: &'a Bump) -> Self { *self } } -impl<'a> RemoveSpaces<'a> for IngestedFileAnnotation<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for IngestedFileAnnotation<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { IngestedFileAnnotation { before_colon: &[], - annotation: self.annotation.remove_spaces(arena), + annotation: self.annotation.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for Implements<'a> { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Implements<'a> { + fn normalize(&self, _arena: &'a Bump) -> Self { Implements::Implements } } -impl<'a> RemoveSpaces<'a> for AbilityMember<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for AbilityMember<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { AbilityMember { - name: self.name.remove_spaces(arena), - typ: self.typ.remove_spaces(arena), + name: self.name.normalize(arena), + typ: self.typ.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for WhenBranch<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for WhenBranch<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { WhenBranch { - patterns: self.patterns.remove_spaces(arena), - value: self.value.remove_spaces(arena), - guard: self.guard.remove_spaces(arena), + patterns: self.patterns.normalize(arena), + value: self.value.normalize(arena), + guard: self.guard.normalize(arena), } } } -impl<'a, T: RemoveSpaces<'a> + Copy + std::fmt::Debug> RemoveSpaces<'a> for AssignedField<'a, T> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a, T: Normalize<'a> + Copy + std::fmt::Debug> Normalize<'a> for AssignedField<'a, T> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { AssignedField::RequiredValue(a, _, c) => AssignedField::RequiredValue( - a.remove_spaces(arena), + a.normalize(arena), arena.alloc([]), - arena.alloc(c.remove_spaces(arena)), + arena.alloc(c.normalize(arena)), ), AssignedField::OptionalValue(a, _, c) => AssignedField::OptionalValue( - a.remove_spaces(arena), + a.normalize(arena), arena.alloc([]), - arena.alloc(c.remove_spaces(arena)), + arena.alloc(c.normalize(arena)), ), AssignedField::IgnoredValue(a, _, c) => AssignedField::IgnoredValue( - a.remove_spaces(arena), + a.normalize(arena), arena.alloc([]), - arena.alloc(c.remove_spaces(arena)), + arena.alloc(c.normalize(arena)), ), - AssignedField::LabelOnly(a) => AssignedField::LabelOnly(a.remove_spaces(arena)), + AssignedField::LabelOnly(a) => AssignedField::LabelOnly(a.normalize(arena)), AssignedField::Malformed(a) => AssignedField::Malformed(a), - AssignedField::SpaceBefore(a, _) => a.remove_spaces(arena), - AssignedField::SpaceAfter(a, _) => a.remove_spaces(arena), + AssignedField::SpaceBefore(a, _) => a.normalize(arena), + AssignedField::SpaceAfter(a, _) => a.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for OldRecordBuilderField<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for OldRecordBuilderField<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { OldRecordBuilderField::Value(a, _, c) => OldRecordBuilderField::Value( - a.remove_spaces(arena), + a.normalize(arena), &[], - arena.alloc(c.remove_spaces(arena)), + arena.alloc(c.normalize(arena)), ), OldRecordBuilderField::ApplyValue(a, _, _, c) => OldRecordBuilderField::ApplyValue( - a.remove_spaces(arena), + a.normalize(arena), &[], &[], - arena.alloc(c.remove_spaces(arena)), + arena.alloc(c.normalize(arena)), ), OldRecordBuilderField::LabelOnly(a) => { - OldRecordBuilderField::LabelOnly(a.remove_spaces(arena)) + OldRecordBuilderField::LabelOnly(a.normalize(arena)) } OldRecordBuilderField::Malformed(a) => OldRecordBuilderField::Malformed(a), - OldRecordBuilderField::SpaceBefore(a, _) => a.remove_spaces(arena), - OldRecordBuilderField::SpaceAfter(a, _) => a.remove_spaces(arena), + OldRecordBuilderField::SpaceBefore(a, _) => a.normalize(arena), + OldRecordBuilderField::SpaceAfter(a, _) => a.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for StrLiteral<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for StrLiteral<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { StrLiteral::PlainLine(t) => StrLiteral::PlainLine(t), StrLiteral::Line(t) => { @@ -616,7 +613,7 @@ impl<'a> RemoveSpaces<'a> for StrLiteral<'a> { } if !needs_merge { - return StrLiteral::Line(t.remove_spaces(arena)); + return StrLiteral::Line(t.normalize(arena)); } let mut new_segments = Vec::new_in(arena); @@ -669,14 +666,14 @@ fn normalize_str_segments<'a>( let text = std::mem::replace(last_text, String::new_in(arena)); new_segments.push(StrSegment::Plaintext(text.into_bump_str())); } - new_segments.push(StrSegment::Interpolated(e.remove_spaces(arena))); + new_segments.push(StrSegment::Interpolated(e.normalize(arena))); } StrSegment::DeprecatedInterpolated(e) => { if !last_text.is_empty() { let text = std::mem::replace(last_text, String::new_in(arena)); new_segments.push(StrSegment::Plaintext(text.into_bump_str())); } - new_segments.push(StrSegment::Interpolated(e.remove_spaces(arena))); + new_segments.push(StrSegment::Interpolated(e.normalize(arena))); } } } @@ -689,28 +686,26 @@ fn test_str_normalize() { let a = parse_expr_with(&arena, r#""a\nb""#).unwrap(); let b = parse_expr_with(&arena, "\"\"\"\na\nb\"\"\"").unwrap(); - let ar = a.remove_spaces(&arena); - let br = b.remove_spaces(&arena); + let ar = a.normalize(&arena); + let br = b.normalize(&arena); assert_eq!(ar, br); } -impl<'a> RemoveSpaces<'a> for StrSegment<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for StrSegment<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { StrSegment::Plaintext(t) => StrSegment::Plaintext(t), - StrSegment::Unicode(t) => StrSegment::Unicode(t.remove_spaces(arena)), + StrSegment::Unicode(t) => StrSegment::Unicode(t.normalize(arena)), StrSegment::EscapedChar(c) => StrSegment::EscapedChar(c), - StrSegment::Interpolated(t) => StrSegment::Interpolated(t.remove_spaces(arena)), - StrSegment::DeprecatedInterpolated(t) => { - StrSegment::Interpolated(t.remove_spaces(arena)) - } + StrSegment::Interpolated(t) => StrSegment::Interpolated(t.normalize(arena)), + StrSegment::DeprecatedInterpolated(t) => StrSegment::Interpolated(t.normalize(arena)), } } } -impl<'a> RemoveSpaces<'a> for Expr<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Expr<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { Expr::Float(a) => Expr::Float(a), Expr::Num(a) => Expr::Num(a), @@ -723,30 +718,30 @@ impl<'a> RemoveSpaces<'a> for Expr<'a> { 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::Str(a) => Expr::Str(a.normalize(arena)), + Expr::RecordAccess(a, b) => Expr::RecordAccess(arena.alloc(a.normalize(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::TupleAccess(a, b) => Expr::TupleAccess(arena.alloc(a.normalize(arena)), b), + Expr::TaskAwaitBang(a) => Expr::TaskAwaitBang(arena.alloc(a.normalize(arena))), + Expr::List(a) => Expr::List(a.normalize(arena)), Expr::RecordUpdate { update, fields } => Expr::RecordUpdate { - update: arena.alloc(update.remove_spaces(arena)), - fields: fields.remove_spaces(arena), + update: arena.alloc(update.normalize(arena)), + fields: fields.normalize(arena), }, - Expr::Record(a) => Expr::Record(a.remove_spaces(arena)), - Expr::OldRecordBuilder(a) => Expr::OldRecordBuilder(a.remove_spaces(arena)), + Expr::Record(a) => Expr::Record(a.normalize(arena)), + Expr::OldRecordBuilder(a) => Expr::OldRecordBuilder(a.normalize(arena)), Expr::RecordBuilder { mapper, fields } => Expr::RecordBuilder { - mapper: arena.alloc(mapper.remove_spaces(arena)), - fields: fields.remove_spaces(arena), + mapper: arena.alloc(mapper.normalize(arena)), + fields: fields.normalize(arena), }, - Expr::Tuple(a) => Expr::Tuple(a.remove_spaces(arena)), + Expr::Tuple(a) => Expr::Tuple(a.normalize(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)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), Expr::Crash => Expr::Crash, Expr::Defs(a, b) => { @@ -757,74 +752,68 @@ impl<'a> RemoveSpaces<'a> for Expr<'a> { defs.spaces.clear(); for type_def in defs.type_defs.iter_mut() { - *type_def = type_def.remove_spaces(arena); + *type_def = type_def.normalize(arena); } for value_def in defs.value_defs.iter_mut() { - *value_def = value_def.remove_spaces(arena); + *value_def = value_def.normalize(arena); } - Expr::Defs(arena.alloc(defs), arena.alloc(b.remove_spaces(arena))) + Expr::Defs(arena.alloc(defs), arena.alloc(b.normalize(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)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), + arena.alloc(c.normalize(arena)), ), Expr::Expect(a, b) => Expr::Expect( - arena.alloc(a.remove_spaces(arena)), - arena.alloc(b.remove_spaces(arena)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), Expr::Dbg(a, b) => Expr::Dbg( - arena.alloc(a.remove_spaces(arena)), - arena.alloc(b.remove_spaces(arena)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), Expr::LowLevelDbg(x, a, b) => Expr::LowLevelDbg( x, - arena.alloc(a.remove_spaces(arena)), - arena.alloc(b.remove_spaces(arena)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), - 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::Apply(a, b, c) => { + Expr::Apply(arena.alloc(a.normalize(arena)), b.normalize(arena), c) } + Expr::BinOps(a, b) => Expr::BinOps(a.normalize(arena), arena.alloc(b.normalize(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::UnaryOp(arena.alloc(a.normalize(arena)), b.normalize(arena)) } + Expr::If(a, b) => Expr::If(a.normalize(arena), arena.alloc(b.normalize(arena))), + Expr::When(a, b) => Expr::When(arena.alloc(a.normalize(arena)), b.normalize(arena)), Expr::ParensAround(a) => { // The formatter can remove redundant parentheses, so also remove these when normalizing for comparison. - a.remove_spaces(arena) + a.normalize(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::SpaceBefore(a, _) => a.remove_spaces(arena), - Expr::SpaceAfter(a, _) => a.remove_spaces(arena), + Expr::SpaceBefore(a, _) => a.normalize(arena), + Expr::SpaceAfter(a, _) => a.normalize(arena), Expr::SingleQuote(a) => Expr::Num(a), Expr::MultipleOldRecordBuilders(a) => { - Expr::MultipleOldRecordBuilders(arena.alloc(a.remove_spaces(arena))) + Expr::MultipleOldRecordBuilders(arena.alloc(a.normalize(arena))) } Expr::UnappliedOldRecordBuilder(a) => { - Expr::UnappliedOldRecordBuilder(arena.alloc(a.remove_spaces(arena))) + Expr::UnappliedOldRecordBuilder(arena.alloc(a.normalize(arena))) } Expr::EmptyRecordBuilder(a) => { - Expr::EmptyRecordBuilder(arena.alloc(a.remove_spaces(arena))) + Expr::EmptyRecordBuilder(arena.alloc(a.normalize(arena))) } Expr::SingleFieldRecordBuilder(a) => { - Expr::SingleFieldRecordBuilder(arena.alloc(a.remove_spaces(arena))) + Expr::SingleFieldRecordBuilder(arena.alloc(a.normalize(arena))) } Expr::OptionalFieldInRecordBuilder(a, b) => Expr::OptionalFieldInRecordBuilder( - arena.alloc(a.remove_spaces(arena)), - arena.alloc(b.remove_spaces(arena)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), } } @@ -853,26 +842,26 @@ fn remove_spaces_bad_ident(ident: BadIdent) -> BadIdent { } } -impl<'a> RemoveSpaces<'a> for Pattern<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Pattern<'a> { + fn normalize(&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)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), - Pattern::RecordDestructure(a) => Pattern::RecordDestructure(a.remove_spaces(arena)), + Pattern::RecordDestructure(a) => Pattern::RecordDestructure(a.normalize(arena)), Pattern::RequiredField(a, b) => { - Pattern::RequiredField(a, arena.alloc(b.remove_spaces(arena))) + Pattern::RequiredField(a, arena.alloc(b.normalize(arena))) } Pattern::OptionalField(a, b) => { - Pattern::OptionalField(a, arena.alloc(b.remove_spaces(arena))) + Pattern::OptionalField(a, arena.alloc(b.normalize(arena))) } Pattern::As(pattern, pattern_as) => Pattern::As( - arena.alloc(pattern.remove_spaces(arena)), - pattern_as.remove_spaces(arena), + arena.alloc(pattern.normalize(arena)), + pattern_as.normalize(arena), ), Pattern::NumLiteral(a) => Pattern::NumLiteral(a), Pattern::NonBase10Literal { @@ -892,136 +881,133 @@ impl<'a> RemoveSpaces<'a> for Pattern<'a> { 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::SpaceBefore(a, _) => a.normalize(arena), + Pattern::SpaceAfter(a, _) => a.normalize(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::List(pats) => Pattern::List(pats.normalize(arena)), + Pattern::Tuple(pats) => Pattern::Tuple(pats.normalize(arena)), Pattern::ListRest(opt_pattern_as) => Pattern::ListRest( - opt_pattern_as - .map(|(_, pattern_as)| ([].as_ref(), pattern_as.remove_spaces(arena))), + opt_pattern_as.map(|(_, pattern_as)| ([].as_ref(), pattern_as.normalize(arena))), ), } } } -impl<'a> RemoveSpaces<'a> for TypeAnnotation<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for TypeAnnotation<'a> { + fn normalize(&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)), + arena.alloc(a.normalize(arena)), + arena.alloc(b.normalize(arena)), ), - TypeAnnotation::Apply(a, b, c) => TypeAnnotation::Apply(a, b, c.remove_spaces(arena)), + TypeAnnotation::Apply(a, b, c) => TypeAnnotation::Apply(a, b, c.normalize(arena)), TypeAnnotation::BoundVariable(a) => TypeAnnotation::BoundVariable(a), TypeAnnotation::As(a, _, TypeHeader { name, vars }) => TypeAnnotation::As( - arena.alloc(a.remove_spaces(arena)), + arena.alloc(a.normalize(arena)), &[], TypeHeader { - name: name.remove_spaces(arena), - vars: vars.remove_spaces(arena), + name: name.normalize(arena), + vars: vars.normalize(arena), }, ), TypeAnnotation::Tuple { elems: fields, ext } => TypeAnnotation::Tuple { - elems: fields.remove_spaces(arena), - ext: ext.remove_spaces(arena), + elems: fields.normalize(arena), + ext: ext.normalize(arena), }, TypeAnnotation::Record { fields, ext } => TypeAnnotation::Record { - fields: fields.remove_spaces(arena), - ext: ext.remove_spaces(arena), + fields: fields.normalize(arena), + ext: ext.normalize(arena), }, TypeAnnotation::TagUnion { ext, tags } => TypeAnnotation::TagUnion { - ext: ext.remove_spaces(arena), - tags: tags.remove_spaces(arena), + ext: ext.normalize(arena), + tags: tags.normalize(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)), + arena.alloc(annot.normalize(arena)), + arena.alloc(has_clauses.normalize(arena)), ), - TypeAnnotation::SpaceBefore(a, _) => a.remove_spaces(arena), - TypeAnnotation::SpaceAfter(a, _) => a.remove_spaces(arena), + TypeAnnotation::SpaceBefore(a, _) => a.normalize(arena), + TypeAnnotation::SpaceAfter(a, _) => a.normalize(arena), TypeAnnotation::Malformed(a) => TypeAnnotation::Malformed(a), } } } -impl<'a> RemoveSpaces<'a> for ImplementsClause<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImplementsClause<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { ImplementsClause { - var: self.var.remove_spaces(arena), - abilities: self.abilities.remove_spaces(arena), + var: self.var.normalize(arena), + abilities: self.abilities.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for Tag<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Tag<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { Tag::Apply { name, args } => Tag::Apply { - name: name.remove_spaces(arena), - args: args.remove_spaces(arena), + name: name.normalize(arena), + args: args.normalize(arena), }, Tag::Malformed(a) => Tag::Malformed(a), - Tag::SpaceBefore(a, _) => a.remove_spaces(arena), - Tag::SpaceAfter(a, _) => a.remove_spaces(arena), + Tag::SpaceBefore(a, _) => a.normalize(arena), + Tag::SpaceAfter(a, _) => a.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for AbilityImpls<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for AbilityImpls<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { - AbilityImpls::AbilityImpls(impls) => { - AbilityImpls::AbilityImpls(impls.remove_spaces(arena)) - } + AbilityImpls::AbilityImpls(impls) => AbilityImpls::AbilityImpls(impls.normalize(arena)), AbilityImpls::SpaceBefore(has, _) | AbilityImpls::SpaceAfter(has, _) => { - has.remove_spaces(arena) + has.normalize(arena) } } } } -impl<'a> RemoveSpaces<'a> for ImplementsAbility<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImplementsAbility<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { ImplementsAbility::ImplementsAbility { ability, impls } => { ImplementsAbility::ImplementsAbility { - ability: ability.remove_spaces(arena), - impls: impls.remove_spaces(arena), + ability: ability.normalize(arena), + impls: impls.normalize(arena), } } ImplementsAbility::SpaceBefore(has, _) | ImplementsAbility::SpaceAfter(has, _) => { - has.remove_spaces(arena) + has.normalize(arena) } } } } -impl<'a> RemoveSpaces<'a> for ImplementsAbilities<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ImplementsAbilities<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match *self { ImplementsAbilities::Implements(derived) => { - ImplementsAbilities::Implements(derived.remove_spaces(arena)) + ImplementsAbilities::Implements(derived.normalize(arena)) } ImplementsAbilities::SpaceBefore(derived, _) - | ImplementsAbilities::SpaceAfter(derived, _) => derived.remove_spaces(arena), + | ImplementsAbilities::SpaceAfter(derived, _) => derived.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for PatternAs<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PatternAs<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { PatternAs { spaces_before: &[], - identifier: self.identifier.remove_spaces(arena), + identifier: self.identifier.normalize(arena), } } } -impl<'a> RemoveSpaces<'a> for EExpr<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EExpr<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EExpr::TrailingOperator(_pos) => EExpr::TrailingOperator(Position::zero()), EExpr::Start(_pos) => EExpr::Start(Position::zero()), @@ -1032,24 +1018,22 @@ impl<'a> RemoveSpaces<'a> for EExpr<'a> { EExpr::Access(_pos) => EExpr::Access(Position::zero()), EExpr::UnaryNot(_pos) => EExpr::UnaryNot(Position::zero()), EExpr::UnaryNegate(_pos) => EExpr::UnaryNegate(Position::zero()), - EExpr::BadOperator(inner_err, _pos) => EExpr::BadOperator( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + EExpr::BadOperator(inner_err, _pos) => { + EExpr::BadOperator(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } EExpr::DefMissingFinalExpr(_pos) => EExpr::DefMissingFinalExpr(Position::zero()), EExpr::DefMissingFinalExpr2(inner_err, _pos) => EExpr::DefMissingFinalExpr2( - arena.alloc(inner_err.remove_spaces(arena)), + arena.alloc(inner_err.normalize(arena)), Position::zero(), ), EExpr::Type(inner_err, _pos) => { - EExpr::Type(inner_err.remove_spaces(arena), Position::zero()) + EExpr::Type(inner_err.normalize(arena), Position::zero()) + } + EExpr::Pattern(inner_err, _pos) => { + EExpr::Pattern(arena.alloc(inner_err.normalize(arena)), Position::zero()) } - EExpr::Pattern(inner_err, _pos) => EExpr::Pattern( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), EExpr::Ability(inner_err, _pos) => { - EExpr::Ability(inner_err.remove_spaces(arena), Position::zero()) + EExpr::Ability(inner_err.normalize(arena), Position::zero()) } EExpr::IndentDefBody(_pos) => EExpr::IndentDefBody(Position::zero()), EExpr::IndentEquals(_pos) => EExpr::IndentEquals(Position::zero()), @@ -1068,30 +1052,26 @@ impl<'a> RemoveSpaces<'a> for EExpr<'a> { EExpr::BackpassContinue(_pos) => EExpr::BackpassContinue(Position::zero()), EExpr::DbgContinue(_pos) => EExpr::DbgContinue(Position::zero()), EExpr::When(inner_err, _pos) => { - EExpr::When(inner_err.remove_spaces(arena), Position::zero()) - } - EExpr::If(inner_err, _pos) => { - EExpr::If(inner_err.remove_spaces(arena), Position::zero()) + EExpr::When(inner_err.normalize(arena), Position::zero()) } + EExpr::If(inner_err, _pos) => EExpr::If(inner_err.normalize(arena), Position::zero()), EExpr::Expect(inner_err, _pos) => { - EExpr::Expect(inner_err.remove_spaces(arena), Position::zero()) - } - EExpr::Dbg(inner_err, _pos) => { - EExpr::Dbg(inner_err.remove_spaces(arena), Position::zero()) + EExpr::Expect(inner_err.normalize(arena), Position::zero()) } + EExpr::Dbg(inner_err, _pos) => EExpr::Dbg(inner_err.normalize(arena), Position::zero()), EExpr::Import(inner_err, _pos) => { - EExpr::Import(inner_err.remove_spaces(arena), Position::zero()) + EExpr::Import(inner_err.normalize(arena), Position::zero()) } EExpr::Closure(inner_err, _pos) => { - EExpr::Closure(inner_err.remove_spaces(arena), Position::zero()) + EExpr::Closure(inner_err.normalize(arena), Position::zero()) } EExpr::Underscore(_pos) => EExpr::Underscore(Position::zero()), EExpr::Crash(_pos) => EExpr::Crash(Position::zero()), EExpr::InParens(inner_err, _pos) => { - EExpr::InParens(inner_err.remove_spaces(arena), Position::zero()) + EExpr::InParens(inner_err.normalize(arena), Position::zero()) } EExpr::Record(inner_err, _pos) => { - EExpr::Record(inner_err.remove_spaces(arena), Position::zero()) + EExpr::Record(inner_err.normalize(arena), Position::zero()) } EExpr::OptionalValueInOldRecordBuilder(_pos) => { EExpr::OptionalValueInOldRecordBuilder(Region::zero()) @@ -1099,12 +1079,10 @@ impl<'a> RemoveSpaces<'a> for EExpr<'a> { EExpr::IgnoredValueInOldRecordBuilder(_pos) => { EExpr::OptionalValueInOldRecordBuilder(Region::zero()) } - EExpr::Str(inner_err, _pos) => { - EExpr::Str(inner_err.remove_spaces(arena), Position::zero()) - } + EExpr::Str(inner_err, _pos) => EExpr::Str(inner_err.normalize(arena), Position::zero()), EExpr::Number(inner_err, _pos) => EExpr::Number(inner_err.clone(), Position::zero()), EExpr::List(inner_err, _pos) => { - EExpr::List(inner_err.remove_spaces(arena), Position::zero()) + EExpr::List(inner_err.normalize(arena), Position::zero()) } EExpr::IndentStart(_pos) => EExpr::IndentStart(Position::zero()), EExpr::IndentEnd(_pos) => EExpr::IndentEnd(Position::zero()), @@ -1124,22 +1102,21 @@ impl<'a> RemoveSpaces<'a> for EExpr<'a> { } } -impl<'a> RemoveSpaces<'a> for EList<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EList<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EList::Open(_pos) => EList::Open(Position::zero()), EList::End(_pos) => EList::End(Position::zero()), EList::Space(inner_err, _pos) => EList::Space(*inner_err, Position::zero()), - EList::Expr(inner_err, _pos) => EList::Expr( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + EList::Expr(inner_err, _pos) => { + EList::Expr(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } } } } -impl<'a> RemoveSpaces<'a> for EString<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EString<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EString::Open(_) => EString::Open(Position::zero()), EString::CodePtOpen(_) => EString::CodePtOpen(Position::zero()), @@ -1153,7 +1130,7 @@ impl<'a> RemoveSpaces<'a> for EString<'a> { EString::EndlessSingleQuote(_) => EString::EndlessSingleQuote(Position::zero()), EString::UnknownEscape(_) => EString::UnknownEscape(Position::zero()), EString::Format(inner, _) => { - EString::Format(arena.alloc(inner.remove_spaces(arena)), Position::zero()) + EString::Format(arena.alloc(inner.normalize(arena)), Position::zero()) } EString::FormatEnd(_) => EString::FormatEnd(Position::zero()), EString::MultilineInsufficientIndent(_) => { @@ -1166,8 +1143,8 @@ impl<'a> RemoveSpaces<'a> for EString<'a> { } } -impl<'a> RemoveSpaces<'a> for EClosure<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EClosure<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EClosure::Space(inner_err, _) => EClosure::Space(*inner_err, Position::zero()), EClosure::Start(_) => EClosure::Start(Position::zero()), @@ -1175,12 +1152,11 @@ impl<'a> RemoveSpaces<'a> for EClosure<'a> { EClosure::Comma(_) => EClosure::Comma(Position::zero()), EClosure::Arg(_) => EClosure::Arg(Position::zero()), EClosure::Pattern(inner_err, _) => { - EClosure::Pattern(inner_err.remove_spaces(arena), Position::zero()) + EClosure::Pattern(inner_err.normalize(arena), Position::zero()) + } + EClosure::Body(inner_err, _) => { + EClosure::Body(arena.alloc(inner_err.normalize(arena)), Position::zero()) } - EClosure::Body(inner_err, _) => EClosure::Body( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), EClosure::IndentArrow(_) => EClosure::IndentArrow(Position::zero()), EClosure::IndentBody(_) => EClosure::IndentBody(Position::zero()), EClosure::IndentArg(_) => EClosure::IndentArg(Position::zero()), @@ -1188,23 +1164,22 @@ impl<'a> RemoveSpaces<'a> for EClosure<'a> { } } -impl<'a> RemoveSpaces<'a> for EInParens<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EInParens<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EInParens::End(_) => EInParens::End(Position::zero()), EInParens::Open(_) => EInParens::Open(Position::zero()), EInParens::Empty(_) => EInParens::Empty(Position::zero()), - EInParens::Expr(inner_err, _) => EInParens::Expr( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + EInParens::Expr(inner_err, _) => { + EInParens::Expr(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } EInParens::Space(inner_err, _) => EInParens::Space(*inner_err, Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for ERecord<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ERecord<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ERecord::End(_) => ERecord::End(Position::zero()), ERecord::Open(_) => ERecord::Open(Position::zero()), @@ -1214,24 +1189,23 @@ impl<'a> RemoveSpaces<'a> for ERecord<'a> { ERecord::QuestionMark(_) => ERecord::QuestionMark(Position::zero()), ERecord::Arrow(_) => ERecord::Arrow(Position::zero()), ERecord::Ampersand(_) => ERecord::Ampersand(Position::zero()), - ERecord::Expr(inner_err, _) => ERecord::Expr( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + ERecord::Expr(inner_err, _) => { + ERecord::Expr(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } ERecord::Space(inner_err, _) => ERecord::Space(*inner_err, Position::zero()), ERecord::Prefix(_) => ERecord::Prefix(Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for EPattern<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EPattern<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EPattern::Record(inner_err, _) => { - EPattern::Record(inner_err.remove_spaces(arena), Position::zero()) + EPattern::Record(inner_err.normalize(arena), Position::zero()) } EPattern::List(inner_err, _) => { - EPattern::List(inner_err.remove_spaces(arena), Position::zero()) + EPattern::List(inner_err.normalize(arena), Position::zero()) } EPattern::AsKeyword(_) => EPattern::AsKeyword(Position::zero()), EPattern::AsIdentifier(_) => EPattern::AsIdentifier(Position::zero()), @@ -1241,7 +1215,7 @@ impl<'a> RemoveSpaces<'a> for EPattern<'a> { EPattern::End(_) => EPattern::End(Position::zero()), EPattern::Space(inner_err, _) => EPattern::Space(*inner_err, Position::zero()), EPattern::PInParens(inner_err, _) => { - EPattern::PInParens(inner_err.remove_spaces(arena), Position::zero()) + EPattern::PInParens(inner_err.normalize(arena), Position::zero()) } EPattern::NumLiteral(inner_err, _) => { EPattern::NumLiteral(inner_err.clone(), Position::zero()) @@ -1254,8 +1228,8 @@ impl<'a> RemoveSpaces<'a> for EPattern<'a> { } } -impl<'a> RemoveSpaces<'a> for EImport<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EImport<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EImport::Import(_) => EImport::Import(Position::zero()), EImport::IndentStart(_) => EImport::IndentStart(Position::zero()), @@ -1263,7 +1237,7 @@ impl<'a> RemoveSpaces<'a> for EImport<'a> { EImport::PackageShorthandDot(_) => EImport::PackageShorthandDot(Position::zero()), EImport::ModuleName(_) => EImport::ModuleName(Position::zero()), EImport::Params(inner_err, _) => { - EImport::Params(inner_err.remove_spaces(arena), Position::zero()) + EImport::Params(inner_err.normalize(arena), Position::zero()) } EImport::IndentAs(_) => EImport::IndentAs(Position::zero()), EImport::As(_) => EImport::As(Position::zero()), @@ -1283,7 +1257,7 @@ impl<'a> RemoveSpaces<'a> for EImport<'a> { EImport::Colon(_) => EImport::Colon(Position::zero()), EImport::IndentAnnotation(_) => EImport::IndentAnnotation(Position::zero()), EImport::Annotation(inner_err, _) => { - EImport::Annotation(inner_err.remove_spaces(arena), Position::zero()) + EImport::Annotation(inner_err.normalize(arena), Position::zero()) } EImport::Space(inner_err, _) => EImport::Space(*inner_err, Position::zero()), EImport::EndNewline(_) => EImport::EndNewline(Position::zero()), @@ -1291,25 +1265,25 @@ impl<'a> RemoveSpaces<'a> for EImport<'a> { } } -impl<'a> RemoveSpaces<'a> for EType<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EType<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EType::Space(inner_err, _) => EType::Space(*inner_err, Position::zero()), EType::UnderscoreSpacing(_) => EType::UnderscoreSpacing(Position::zero()), EType::TRecord(inner_err, _) => { - EType::TRecord(inner_err.remove_spaces(arena), Position::zero()) + EType::TRecord(inner_err.normalize(arena), Position::zero()) } EType::TTagUnion(inner_err, _) => { - EType::TTagUnion(inner_err.remove_spaces(arena), Position::zero()) + EType::TTagUnion(inner_err.normalize(arena), Position::zero()) } EType::TInParens(inner_err, _) => { - EType::TInParens(inner_err.remove_spaces(arena), Position::zero()) + EType::TInParens(inner_err.normalize(arena), Position::zero()) } EType::TApply(inner_err, _) => { - EType::TApply(inner_err.remove_spaces(arena), Position::zero()) + EType::TApply(inner_err.normalize(arena), Position::zero()) } EType::TInlineAlias(inner_err, _) => { - EType::TInlineAlias(inner_err.remove_spaces(arena), Position::zero()) + EType::TInlineAlias(inner_err.normalize(arena), Position::zero()) } EType::TBadTypeVariable(_) => EType::TBadTypeVariable(Position::zero()), EType::TWildcard(_) => EType::TWildcard(Position::zero()), @@ -1320,7 +1294,7 @@ impl<'a> RemoveSpaces<'a> for EType<'a> { EType::TWhereBar(_) => EType::TWhereBar(Position::zero()), EType::TImplementsClause(_) => EType::TImplementsClause(Position::zero()), EType::TAbilityImpl(inner_err, _) => { - EType::TAbilityImpl(inner_err.remove_spaces(arena), Position::zero()) + EType::TAbilityImpl(inner_err.normalize(arena), Position::zero()) } EType::TIndentStart(_) => EType::TIndentStart(Position::zero()), EType::TIndentEnd(_) => EType::TIndentEnd(Position::zero()), @@ -1329,12 +1303,12 @@ impl<'a> RemoveSpaces<'a> for EType<'a> { } } -impl<'a> RemoveSpaces<'a> for EImportParams<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EImportParams<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EImportParams::Indent(_) => EImportParams::Indent(Position::zero()), EImportParams::Record(inner_err, _) => { - EImportParams::Record(inner_err.remove_spaces(arena), Position::zero()) + EImportParams::Record(inner_err.normalize(arena), Position::zero()) } EImportParams::RecordUpdateFound(_) => EImportParams::RecordUpdateFound(Region::zero()), EImportParams::RecordApplyFound(_) => EImportParams::RecordApplyFound(Region::zero()), @@ -1351,23 +1325,22 @@ impl<'a> RemoveSpaces<'a> for EImportParams<'a> { } } -impl<'a> RemoveSpaces<'a> for PInParens<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PInParens<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { PInParens::Empty(_) => PInParens::Empty(Position::zero()), PInParens::End(_) => PInParens::End(Position::zero()), PInParens::Open(_) => PInParens::Open(Position::zero()), - PInParens::Pattern(inner_err, _) => PInParens::Pattern( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + PInParens::Pattern(inner_err, _) => { + PInParens::Pattern(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } PInParens::Space(inner_err, _) => PInParens::Space(*inner_err, Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for ETypeAbilityImpl<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypeAbilityImpl<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ETypeAbilityImpl::End(_) => ETypeAbilityImpl::End(Position::zero()), ETypeAbilityImpl::Open(_) => ETypeAbilityImpl::Open(Position::zero()), @@ -1378,19 +1351,17 @@ impl<'a> RemoveSpaces<'a> for ETypeAbilityImpl<'a> { ETypeAbilityImpl::Colon(_) => ETypeAbilityImpl::Colon(Position::zero()), ETypeAbilityImpl::Arrow(_) => ETypeAbilityImpl::Arrow(Position::zero()), ETypeAbilityImpl::Optional(_) => ETypeAbilityImpl::Optional(Position::zero()), - ETypeAbilityImpl::Type(inner_err, _) => ETypeAbilityImpl::Type( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + ETypeAbilityImpl::Type(inner_err, _) => { + ETypeAbilityImpl::Type(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } ETypeAbilityImpl::Space(inner_err, _) => { ETypeAbilityImpl::Space(*inner_err, Position::zero()) } ETypeAbilityImpl::QuestionMark(_) => ETypeAbilityImpl::QuestionMark(Position::zero()), ETypeAbilityImpl::Ampersand(_) => ETypeAbilityImpl::Ampersand(Position::zero()), - ETypeAbilityImpl::Expr(inner_err, _) => ETypeAbilityImpl::Expr( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + ETypeAbilityImpl::Expr(inner_err, _) => { + ETypeAbilityImpl::Expr(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } ETypeAbilityImpl::IndentBar(_) => ETypeAbilityImpl::IndentBar(Position::zero()), ETypeAbilityImpl::IndentAmpersand(_) => { ETypeAbilityImpl::IndentAmpersand(Position::zero()) @@ -1400,8 +1371,8 @@ impl<'a> RemoveSpaces<'a> for ETypeAbilityImpl<'a> { } } -impl<'a> RemoveSpaces<'a> for ETypeInlineAlias { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypeInlineAlias { + fn normalize(&self, _arena: &'a Bump) -> Self { match self { ETypeInlineAlias::NotAnAlias(_pos) => ETypeInlineAlias::NotAnAlias(Position::zero()), ETypeInlineAlias::Qualified(_pos) => ETypeInlineAlias::Qualified(Position::zero()), @@ -1412,8 +1383,8 @@ impl<'a> RemoveSpaces<'a> for ETypeInlineAlias { } } -impl<'a> RemoveSpaces<'a> for ETypeApply { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypeApply { + fn normalize(&self, _arena: &'a Bump) -> Self { match self { ETypeApply::StartNotUppercase(_) => ETypeApply::StartNotUppercase(Position::zero()), ETypeApply::End(_) => ETypeApply::End(Position::zero()), @@ -1425,16 +1396,15 @@ impl<'a> RemoveSpaces<'a> for ETypeApply { } } -impl<'a> RemoveSpaces<'a> for ETypeInParens<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypeInParens<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ETypeInParens::Empty(_) => ETypeInParens::Empty(Position::zero()), ETypeInParens::End(_) => ETypeInParens::End(Position::zero()), ETypeInParens::Open(_) => ETypeInParens::Open(Position::zero()), - ETypeInParens::Type(inner_err, _) => ETypeInParens::Type( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + ETypeInParens::Type(inner_err, _) => { + ETypeInParens::Type(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } ETypeInParens::Space(inner_err, _) => { ETypeInParens::Space(*inner_err, Position::zero()) } @@ -1444,15 +1414,14 @@ impl<'a> RemoveSpaces<'a> for ETypeInParens<'a> { } } -impl<'a> RemoveSpaces<'a> for ETypeTagUnion<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypeTagUnion<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ETypeTagUnion::End(_) => ETypeTagUnion::End(Position::zero()), ETypeTagUnion::Open(_) => ETypeTagUnion::Open(Position::zero()), - ETypeTagUnion::Type(inner_err, _) => ETypeTagUnion::Type( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + ETypeTagUnion::Type(inner_err, _) => { + ETypeTagUnion::Type(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } ETypeTagUnion::Space(inner_err, _) => { ETypeTagUnion::Space(*inner_err, Position::zero()) } @@ -1460,18 +1429,17 @@ impl<'a> RemoveSpaces<'a> for ETypeTagUnion<'a> { } } -impl<'a> RemoveSpaces<'a> for ETypeRecord<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypeRecord<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ETypeRecord::End(_) => ETypeRecord::End(Position::zero()), ETypeRecord::Open(_) => ETypeRecord::Open(Position::zero()), ETypeRecord::Field(_) => ETypeRecord::Field(Position::zero()), ETypeRecord::Colon(_) => ETypeRecord::Colon(Position::zero()), ETypeRecord::Optional(_) => ETypeRecord::Optional(Position::zero()), - ETypeRecord::Type(inner_err, _) => ETypeRecord::Type( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + ETypeRecord::Type(inner_err, _) => { + ETypeRecord::Type(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } ETypeRecord::Space(inner_err, _) => ETypeRecord::Space(*inner_err, Position::zero()), ETypeRecord::IndentOpen(_) => ETypeRecord::IndentOpen(Position::zero()), ETypeRecord::IndentColon(_) => ETypeRecord::IndentColon(Position::zero()), @@ -1481,79 +1449,71 @@ impl<'a> RemoveSpaces<'a> for ETypeRecord<'a> { } } -impl<'a> RemoveSpaces<'a> for PRecord<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PRecord<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { PRecord::End(_) => PRecord::End(Position::zero()), PRecord::Open(_) => PRecord::Open(Position::zero()), PRecord::Field(_) => PRecord::Field(Position::zero()), PRecord::Colon(_) => PRecord::Colon(Position::zero()), PRecord::Optional(_) => PRecord::Optional(Position::zero()), - PRecord::Pattern(inner_err, _) => PRecord::Pattern( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), - PRecord::Expr(inner_err, _) => PRecord::Expr( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + PRecord::Pattern(inner_err, _) => { + PRecord::Pattern(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } + PRecord::Expr(inner_err, _) => { + PRecord::Expr(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } PRecord::Space(inner_err, _) => PRecord::Space(*inner_err, Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for PList<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for PList<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { PList::End(_) => PList::End(Position::zero()), PList::Open(_) => PList::Open(Position::zero()), PList::Rest(_) => PList::Rest(Position::zero()), - PList::Pattern(inner_err, _) => PList::Pattern( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + PList::Pattern(inner_err, _) => { + PList::Pattern(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } PList::Space(inner_err, _) => PList::Space(*inner_err, Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for EExpect<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EExpect<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EExpect::Space(inner_err, _) => EExpect::Space(*inner_err, Position::zero()), EExpect::Dbg(_) => EExpect::Dbg(Position::zero()), EExpect::Expect(_) => EExpect::Expect(Position::zero()), - EExpect::Condition(inner_err, _) => EExpect::Condition( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), - EExpect::Continuation(inner_err, _) => EExpect::Continuation( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + EExpect::Condition(inner_err, _) => { + EExpect::Condition(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } + EExpect::Continuation(inner_err, _) => { + EExpect::Continuation(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } EExpect::IndentCondition(_) => EExpect::IndentCondition(Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for EIf<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EIf<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EIf::Space(inner_err, _) => EIf::Space(*inner_err, Position::zero()), EIf::If(_) => EIf::If(Position::zero()), EIf::Then(_) => EIf::Then(Position::zero()), EIf::Else(_) => EIf::Else(Position::zero()), - EIf::Condition(inner_err, _) => EIf::Condition( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), - EIf::ThenBranch(inner_err, _) => EIf::ThenBranch( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), - EIf::ElseBranch(inner_err, _) => EIf::ElseBranch( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + EIf::Condition(inner_err, _) => { + EIf::Condition(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } + EIf::ThenBranch(inner_err, _) => { + EIf::ThenBranch(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } + EIf::ElseBranch(inner_err, _) => { + EIf::ElseBranch(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } EIf::IndentCondition(_) => EIf::IndentCondition(Position::zero()), EIf::IndentIf(_) => EIf::IndentIf(Position::zero()), EIf::IndentThenToken(_) => EIf::IndentThenToken(Position::zero()), @@ -1564,30 +1524,27 @@ impl<'a> RemoveSpaces<'a> for EIf<'a> { } } -impl<'a> RemoveSpaces<'a> for EWhen<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EWhen<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EWhen::Space(inner_err, _) => EWhen::Space(*inner_err, Position::zero()), EWhen::When(_) => EWhen::When(Position::zero()), EWhen::Is(_) => EWhen::Is(Position::zero()), EWhen::Pattern(inner_err, _) => { - EWhen::Pattern(inner_err.remove_spaces(arena), Position::zero()) + EWhen::Pattern(inner_err.normalize(arena), Position::zero()) } EWhen::Arrow(_) => EWhen::Arrow(Position::zero()), EWhen::Bar(_) => EWhen::Bar(Position::zero()), EWhen::IfToken(_) => EWhen::IfToken(Position::zero()), - EWhen::IfGuard(inner_err, _) => EWhen::IfGuard( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), - EWhen::Condition(inner_err, _) => EWhen::Condition( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), - EWhen::Branch(inner_err, _) => EWhen::Branch( - arena.alloc(inner_err.remove_spaces(arena)), - Position::zero(), - ), + EWhen::IfGuard(inner_err, _) => { + EWhen::IfGuard(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } + EWhen::Condition(inner_err, _) => { + EWhen::Condition(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } + EWhen::Branch(inner_err, _) => { + EWhen::Branch(arena.alloc(inner_err.normalize(arena)), Position::zero()) + } EWhen::IndentCondition(_) => EWhen::IndentCondition(Position::zero()), EWhen::IndentPattern(_) => EWhen::IndentPattern(Position::zero()), EWhen::IndentArrow(_) => EWhen::IndentArrow(Position::zero()), @@ -1598,12 +1555,12 @@ impl<'a> RemoveSpaces<'a> for EWhen<'a> { } } -impl<'a> RemoveSpaces<'a> for EAbility<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EAbility<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EAbility::Space(inner_err, _) => EAbility::Space(*inner_err, Position::zero()), EAbility::Type(inner_err, _) => { - EAbility::Type(inner_err.remove_spaces(arena), Position::zero()) + EAbility::Type(inner_err.normalize(arena), Position::zero()) } EAbility::DemandAlignment(_alignment, _) => { EAbility::DemandAlignment(0, Position::zero()) @@ -1614,8 +1571,8 @@ impl<'a> RemoveSpaces<'a> for EAbility<'a> { } } -impl<'a> RemoveSpaces<'a> for EGeneratesWith { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EGeneratesWith { + fn normalize(&self, _arena: &'a Bump) -> Self { match self { EGeneratesWith::Open(_) => EGeneratesWith::Open(Position::zero()), EGeneratesWith::With(_) => EGeneratesWith::With(Position::zero()), @@ -1632,8 +1589,8 @@ impl<'a> RemoveSpaces<'a> for EGeneratesWith { } } -impl<'a> RemoveSpaces<'a> for EGenerates { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EGenerates { + fn normalize(&self, _arena: &'a Bump) -> Self { match self { EGenerates::Open(_) => EGenerates::Open(Position::zero()), EGenerates::Generates(_) => EGenerates::Generates(Position::zero()), @@ -1646,8 +1603,8 @@ impl<'a> RemoveSpaces<'a> for EGenerates { } } -impl<'a> RemoveSpaces<'a> for EPackages<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EPackages<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EPackages::Open(_) => EPackages::Open(Position::zero()), EPackages::Space(inner_err, _) => EPackages::Space(*inner_err, Position::zero()), @@ -1658,50 +1615,50 @@ impl<'a> RemoveSpaces<'a> for EPackages<'a> { EPackages::IndentListStart(_) => EPackages::IndentListStart(Position::zero()), EPackages::IndentListEnd(_) => EPackages::IndentListEnd(Position::zero()), EPackages::PackageEntry(inner_err, _) => { - EPackages::PackageEntry(inner_err.remove_spaces(arena), Position::zero()) + EPackages::PackageEntry(inner_err.normalize(arena), Position::zero()) } } } } -impl<'a> RemoveSpaces<'a> for EHeader<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EHeader<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EHeader::Provides(inner_err, _) => { - EHeader::Provides(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Provides(inner_err.normalize(arena), Position::zero()) } EHeader::Params(inner_err, _) => { - EHeader::Params(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Params(inner_err.normalize(arena), Position::zero()) } EHeader::Exposes(inner_err, _) => { - EHeader::Exposes(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Exposes(inner_err.normalize(arena), Position::zero()) } EHeader::Imports(inner_err, _) => { - EHeader::Imports(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Imports(inner_err.normalize(arena), Position::zero()) } EHeader::Requires(inner_err, _) => { - EHeader::Requires(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Requires(inner_err.normalize(arena), Position::zero()) } EHeader::Packages(inner_err, _) => { - EHeader::Packages(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Packages(inner_err.normalize(arena), Position::zero()) } EHeader::Generates(inner_err, _) => { - EHeader::Generates(inner_err.remove_spaces(arena), Position::zero()) + EHeader::Generates(inner_err.normalize(arena), Position::zero()) } EHeader::GeneratesWith(inner_err, _) => { - EHeader::GeneratesWith(inner_err.remove_spaces(arena), Position::zero()) + EHeader::GeneratesWith(inner_err.normalize(arena), Position::zero()) } EHeader::Space(inner_err, _) => EHeader::Space(*inner_err, Position::zero()), EHeader::Start(_) => EHeader::Start(Position::zero()), EHeader::ModuleName(_) => EHeader::ModuleName(Position::zero()), EHeader::AppName(inner_err, _) => { - EHeader::AppName(inner_err.remove_spaces(arena), Position::zero()) + EHeader::AppName(inner_err.normalize(arena), Position::zero()) } EHeader::PackageName(inner_err, _) => { - EHeader::PackageName(inner_err.remove_spaces(arena), Position::zero()) + EHeader::PackageName(inner_err.normalize(arena), Position::zero()) } EHeader::PlatformName(inner_err, _) => { - EHeader::PlatformName(inner_err.remove_spaces(arena), Position::zero()) + EHeader::PlatformName(inner_err.normalize(arena), Position::zero()) } EHeader::IndentStart(_) => EHeader::IndentStart(Position::zero()), EHeader::InconsistentModuleName(_) => EHeader::InconsistentModuleName(Region::zero()), @@ -1709,11 +1666,11 @@ impl<'a> RemoveSpaces<'a> for EHeader<'a> { } } -impl<'a> RemoveSpaces<'a> for EPackageName<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EPackageName<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EPackageName::BadPath(inner_err, _) => { - EPackageName::BadPath(inner_err.remove_spaces(arena), Position::zero()) + EPackageName::BadPath(inner_err.normalize(arena), Position::zero()) } EPackageName::Escapes(_) => EPackageName::Escapes(Position::zero()), EPackageName::Multiline(_) => EPackageName::Multiline(Position::zero()), @@ -1721,8 +1678,8 @@ impl<'a> RemoveSpaces<'a> for EPackageName<'a> { } } -impl<'a> RemoveSpaces<'a> for SyntaxError<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for SyntaxError<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { SyntaxError::Unexpected(_) => SyntaxError::Unexpected(Region::zero()), SyntaxError::OutdentedTooFar => SyntaxError::OutdentedTooFar, @@ -1735,23 +1692,21 @@ impl<'a> RemoveSpaces<'a> for SyntaxError<'a> { } SyntaxError::NotYetImplemented(text) => SyntaxError::NotYetImplemented(text.clone()), SyntaxError::Todo => SyntaxError::Todo, - SyntaxError::Type(err) => SyntaxError::Type(err.remove_spaces(arena)), - SyntaxError::Pattern(err) => SyntaxError::Pattern(err.remove_spaces(arena)), - SyntaxError::Expr(err, _) => { - SyntaxError::Expr(err.remove_spaces(arena), Position::zero()) - } - SyntaxError::Header(err) => SyntaxError::Header(err.remove_spaces(arena)), + SyntaxError::Type(err) => SyntaxError::Type(err.normalize(arena)), + SyntaxError::Pattern(err) => SyntaxError::Pattern(err.normalize(arena)), + SyntaxError::Expr(err, _) => SyntaxError::Expr(err.normalize(arena), Position::zero()), + SyntaxError::Header(err) => SyntaxError::Header(err.normalize(arena)), SyntaxError::Space(inner_err) => SyntaxError::Space(*inner_err), SyntaxError::NotEndOfFile(_) => SyntaxError::NotEndOfFile(Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for EPackageEntry<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EPackageEntry<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EPackageEntry::BadPackage(inner_err, _) => { - EPackageEntry::BadPackage(inner_err.remove_spaces(arena), Position::zero()) + EPackageEntry::BadPackage(inner_err.normalize(arena), Position::zero()) } EPackageEntry::Shorthand(_) => EPackageEntry::Shorthand(Position::zero()), EPackageEntry::Colon(_) => EPackageEntry::Colon(Position::zero()), @@ -1765,8 +1720,8 @@ impl<'a> RemoveSpaces<'a> for EPackageEntry<'a> { } } -impl<'a> RemoveSpaces<'a> for EProvides<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EProvides<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EProvides::Provides(_) => EProvides::Provides(Position::zero()), EProvides::Open(_) => EProvides::Open(Position::zero()), @@ -1779,18 +1734,18 @@ impl<'a> RemoveSpaces<'a> for EProvides<'a> { EProvides::ListEnd(_) => EProvides::ListEnd(Position::zero()), EProvides::Identifier(_) => EProvides::Identifier(Position::zero()), EProvides::Package(inner_err, _) => { - EProvides::Package(inner_err.remove_spaces(arena), Position::zero()) + EProvides::Package(inner_err.normalize(arena), Position::zero()) } EProvides::Space(inner_err, _) => EProvides::Space(*inner_err, Position::zero()), } } } -impl<'a> RemoveSpaces<'a> for EParams<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EParams<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { EParams::Pattern(inner_err, _) => { - EParams::Pattern(inner_err.remove_spaces(arena), Position::zero()) + EParams::Pattern(inner_err.normalize(arena), Position::zero()) } EParams::BeforeArrow(_) => EParams::BeforeArrow(Position::zero()), EParams::Arrow(_) => EParams::Arrow(Position::zero()), @@ -1800,8 +1755,8 @@ impl<'a> RemoveSpaces<'a> for EParams<'a> { } } -impl<'a> RemoveSpaces<'a> for EExposes { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EExposes { + fn normalize(&self, _arena: &'a Bump) -> Self { match self { EExposes::Exposes(_) => EExposes::Exposes(Position::zero()), EExposes::Open(_) => EExposes::Open(Position::zero()), @@ -1815,8 +1770,8 @@ impl<'a> RemoveSpaces<'a> for EExposes { } } -impl<'a> RemoveSpaces<'a> for EImports { - fn remove_spaces(&self, _arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for EImports { + fn normalize(&self, _arena: &'a Bump) -> Self { match self { EImports::Open(_) => EImports::Open(Position::zero()), EImports::Imports(_) => EImports::Imports(Position::zero()), @@ -1841,8 +1796,8 @@ impl<'a> RemoveSpaces<'a> for EImports { } } -impl<'a> RemoveSpaces<'a> for ERequires<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ERequires<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ERequires::Requires(_) => ERequires::Requires(Position::zero()), ERequires::Open(_) => ERequires::Open(Position::zero()), @@ -1851,7 +1806,7 @@ impl<'a> RemoveSpaces<'a> for ERequires<'a> { ERequires::ListStart(_) => ERequires::ListStart(Position::zero()), ERequires::ListEnd(_) => ERequires::ListEnd(Position::zero()), ERequires::TypedIdent(inner_err, _) => { - ERequires::TypedIdent(inner_err.remove_spaces(arena), Position::zero()) + ERequires::TypedIdent(inner_err.normalize(arena), Position::zero()) } ERequires::Rigid(_) => ERequires::Rigid(Position::zero()), ERequires::Space(inner_err, _) => ERequires::Space(*inner_err, Position::zero()), @@ -1859,15 +1814,15 @@ impl<'a> RemoveSpaces<'a> for ERequires<'a> { } } -impl<'a> RemoveSpaces<'a> for ETypedIdent<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for ETypedIdent<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { ETypedIdent::Space(inner_err, _) => ETypedIdent::Space(*inner_err, Position::zero()), ETypedIdent::HasType(_) => ETypedIdent::HasType(Position::zero()), ETypedIdent::IndentHasType(_) => ETypedIdent::IndentHasType(Position::zero()), ETypedIdent::Name(_) => ETypedIdent::Name(Position::zero()), ETypedIdent::Type(inner_err, _) => { - ETypedIdent::Type(inner_err.remove_spaces(arena), Position::zero()) + ETypedIdent::Type(inner_err.normalize(arena), Position::zero()) } ETypedIdent::IndentType(_) => ETypedIdent::IndentType(Position::zero()), ETypedIdent::Identifier(_) => ETypedIdent::Identifier(Position::zero()), diff --git a/crates/compiler/test_syntax/src/minimize.rs b/crates/compiler/test_syntax/src/minimize.rs index 946b31147e..7cd87bd922 100644 --- a/crates/compiler/test_syntax/src/minimize.rs +++ b/crates/compiler/test_syntax/src/minimize.rs @@ -7,7 +7,7 @@ use crate::test_helpers::{Input, InputKind}; use bumpalo::Bump; -use roc_parse::{ast::Malformed, remove_spaces::RemoveSpaces}; +use roc_parse::{ast::Malformed, normalize::Normalize}; pub fn print_minimizations(text: &str, kind: InputKind) { let Some(original_error) = round_trip_once_and_extract_error(text, kind) else { @@ -81,12 +81,7 @@ fn round_trip_once(input: Input<'_>) -> Option { let actual = match input.parse_in(&arena) { Ok(a) => a, - Err(e) => { - return Some(format!( - "Initial parse failed: {:?}", - e.remove_spaces(&arena) - )) - } + Err(e) => return Some(format!("Initial parse failed: {:?}", e.normalize(&arena))), }; if actual.is_malformed() { @@ -97,11 +92,11 @@ fn round_trip_once(input: Input<'_>) -> Option { let reparsed_ast = match output.as_ref().parse_in(&arena) { Ok(r) => r, - Err(e) => return Some(format!("Reparse failed: {:?}", e.remove_spaces(&arena))), + Err(e) => return Some(format!("Reparse failed: {:?}", e.normalize(&arena))), }; - let ast_normalized = actual.remove_spaces(&arena); - let reparsed_ast_normalized = reparsed_ast.remove_spaces(&arena); + let ast_normalized = actual.normalize(&arena); + let reparsed_ast_normalized = reparsed_ast.normalize(&arena); if format!("{ast_normalized:?}") != format!("{reparsed_ast_normalized:?}") { return Some("Different ast".to_string()); diff --git a/crates/compiler/test_syntax/src/test_helpers.rs b/crates/compiler/test_syntax/src/test_helpers.rs index 140e109249..c16c17d001 100644 --- a/crates/compiler/test_syntax/src/test_helpers.rs +++ b/crates/compiler/test_syntax/src/test_helpers.rs @@ -3,8 +3,8 @@ use roc_fmt::{annotation::Formattable, header::fmt_header}; use roc_parse::{ ast::{Defs, Expr, FullAst, Header, Malformed, SpacesBefore}, header::parse_module_defs, + normalize::Normalize, parser::{Parser, SyntaxError}, - remove_spaces::RemoveSpaces, state::State, test_helpers::{parse_defs_with, parse_expr_with, parse_header_with}, }; @@ -128,13 +128,13 @@ impl<'a> Malformed for Output<'a> { } } -impl<'a> RemoveSpaces<'a> for Output<'a> { - fn remove_spaces(&self, arena: &'a Bump) -> Self { +impl<'a> Normalize<'a> for Output<'a> { + fn normalize(&self, arena: &'a Bump) -> Self { match self { - Output::Header(header) => Output::Header(header.remove_spaces(arena)), - Output::ModuleDefs(defs) => Output::ModuleDefs(defs.remove_spaces(arena)), - Output::Expr(expr) => Output::Expr(expr.remove_spaces(arena)), - Output::Full(full) => Output::Full(full.remove_spaces(arena)), + Output::Header(header) => Output::Header(header.normalize(arena)), + Output::ModuleDefs(defs) => Output::ModuleDefs(defs.normalize(arena)), + Output::Expr(expr) => Output::Expr(expr.normalize(arena)), + Output::Full(full) => Output::Full(full.normalize(arena)), } } } @@ -221,8 +221,8 @@ impl<'a> Input<'a> { ); }); - let ast_normalized = actual.remove_spaces(&arena); - let reparsed_ast_normalized = reparsed_ast.remove_spaces(&arena); + let ast_normalized = actual.normalize(&arena); + let reparsed_ast_normalized = reparsed_ast.normalize(&arena); // HACK! // We compare the debug format strings of the ASTs, because I'm finding in practice that _somewhere_ deep inside the ast, diff --git a/crates/compiler/test_syntax/tests/test_fmt.rs b/crates/compiler/test_syntax/tests/test_fmt.rs index a01bae139e..026605d825 100644 --- a/crates/compiler/test_syntax/tests/test_fmt.rs +++ b/crates/compiler/test_syntax/tests/test_fmt.rs @@ -63,7 +63,7 @@ mod test_fmt { match header::parse_header(&arena, State::new(src.as_bytes())) { Ok((actual, state)) => { - use roc_parse::remove_spaces::RemoveSpaces; + use roc_parse::normalize::Normalize; let mut buf = Buf::new_in(&arena); @@ -77,8 +77,8 @@ mod test_fmt { ); }); - let ast_normalized = actual.remove_spaces(&arena); - let reparsed_ast_normalized = reparsed_ast.remove_spaces(&arena); + let ast_normalized = actual.normalize(&arena); + let reparsed_ast_normalized = reparsed_ast.normalize(&arena); // HACK! // We compare the debug format strings of the ASTs, because I'm finding in practice that _somewhere_ deep inside the ast,