Extract spacing from parse::header::* items into explicit Spaced enum

compiler/parse/src/header.rs

@@ -1,4 +1,4 @@
-use crate::ast::{Collection, CommentOrNewline, Spaceable, StrLiteral, TypeAnnotation};
+use crate::ast::{Collection, CommentOrNewline, Spaced, StrLiteral, TypeAnnotation};
 use crate::blankspace::space0_e;
 use crate::ident::lowercase_ident;
 use crate::parser::Progress::{self, *};
@@ -57,11 +57,30 @@ impl<'a> ModuleName<'a> {
     }
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+pub struct ExposedName<'a>(&'a str);
+
+impl<'a> From<ExposedName<'a>> for &'a str {
+    fn from(name: ExposedName<'a>) -> Self {
+        name.0
+    }
+}
+
+impl<'a> ExposedName<'a> {
+    pub fn new(name: &'a str) -> Self {
+        ExposedName(name)
+    }
+
+    pub fn as_str(&'a self) -> &'a str {
+        self.0
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct InterfaceHeader<'a> {
     pub name: Loc<ModuleName<'a>>,
-    pub exposes: Collection<'a, Loc<ExposesEntry<'a, &'a str>>>,
-    pub imports: Collection<'a, Loc<ImportsEntry<'a>>>,
+    pub exposes: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
 
     // Potential comments and newlines - these will typically all be empty.
     pub before_header: &'a [CommentOrNewline<'a>],
@@ -81,9 +100,9 @@ pub enum To<'a> {
 #[derive(Clone, Debug, PartialEq)]
 pub struct AppHeader<'a> {
     pub name: Loc<StrLiteral<'a>>,
-    pub packages: Collection<'a, Loc<PackageEntry<'a>>>,
-    pub imports: Collection<'a, Loc<ImportsEntry<'a>>>,
-    pub provides: Collection<'a, Loc<ExposesEntry<'a, &'a str>>>,
+    pub packages: Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+    pub provides: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
     pub to: Loc<To<'a>>,
 
     // Potential comments and newlines - these will typically all be empty.
@@ -102,7 +121,7 @@ pub struct AppHeader<'a> {
 #[derive(Clone, Debug, PartialEq)]
 pub struct PackageHeader<'a> {
     pub name: Loc<PackageName<'a>>,
-    pub exposes: Vec<'a, Loc<ExposesEntry<'a, &'a str>>>,
+    pub exposes: Vec<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
     pub packages: Vec<'a, (Loc<&'a str>, Loc<PackageOrPath<'a>>)>,
     pub imports: Vec<'a, Loc<ImportsEntry<'a>>>,
 
@@ -118,37 +137,25 @@ pub struct PackageHeader<'a> {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq)]
-pub enum PlatformRigid<'a> {
-    Entry { rigid: &'a str, alias: &'a str },
-
-    // Spaces
-    SpaceBefore(&'a PlatformRigid<'a>, &'a [CommentOrNewline<'a>]),
-    SpaceAfter(&'a PlatformRigid<'a>, &'a [CommentOrNewline<'a>]),
-}
-
-impl<'a> Spaceable<'a> for PlatformRigid<'a> {
-    fn before(&'a self, spaces: &'a [CommentOrNewline<'a>]) -> Self {
-        PlatformRigid::SpaceBefore(self, spaces)
-    }
-    fn after(&'a self, spaces: &'a [CommentOrNewline<'a>]) -> Self {
-        PlatformRigid::SpaceAfter(self, spaces)
-    }
+pub struct PlatformRigid<'a> {
+    pub rigid: &'a str,
+    pub alias: &'a str,
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct PlatformRequires<'a> {
-    pub rigids: Collection<'a, Loc<PlatformRigid<'a>>>,
-    pub signature: Loc<TypedIdent<'a>>,
+    pub rigids: Collection<'a, Loc<Spaced<'a, PlatformRigid<'a>>>>,
+    pub signature: Loc<Spaced<'a, TypedIdent<'a>>>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct PlatformHeader<'a> {
     pub name: Loc<PackageName<'a>>,
     pub requires: PlatformRequires<'a>,
-    pub exposes: Collection<'a, Loc<ExposesEntry<'a, ModuleName<'a>>>>,
-    pub packages: Collection<'a, Loc<PackageEntry<'a>>>,
-    pub imports: Collection<'a, Loc<ImportsEntry<'a>>>,
-    pub provides: Collection<'a, Loc<ExposesEntry<'a, &'a str>>>,
+    pub exposes: Collection<'a, Loc<Spaced<'a, ModuleName<'a>>>>,
+    pub packages: Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>,
+    pub imports: Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>,
+    pub provides: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
     pub effects: Effects<'a>,
 
     // Potential comments and newlines - these will typically all be empty.
@@ -174,26 +181,7 @@ pub struct Effects<'a> {
     pub spaces_after_type_name: &'a [CommentOrNewline<'a>],
     pub effect_shortname: &'a str,
     pub effect_type_name: &'a str,
-    pub entries: Collection<'a, Loc<TypedIdent<'a>>>,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum ExposesEntry<'a, T> {
-    /// e.g. `Task`
-    Exposed(T),
-
-    // Spaces
-    SpaceBefore(&'a ExposesEntry<'a, T>, &'a [CommentOrNewline<'a>]),
-    SpaceAfter(&'a ExposesEntry<'a, T>, &'a [CommentOrNewline<'a>]),
-}
-
-impl<'a, T> Spaceable<'a> for ExposesEntry<'a, T> {
-    fn before(&'a self, spaces: &'a [CommentOrNewline<'a>]) -> Self {
-        ExposesEntry::SpaceBefore(self, spaces)
-    }
-    fn after(&'a self, spaces: &'a [CommentOrNewline<'a>]) -> Self {
-        ExposesEntry::SpaceAfter(self, spaces)
-    }
+    pub entries: Collection<'a, Loc<Spaced<'a, TypedIdent<'a>>>>,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -201,71 +189,35 @@ pub enum ImportsEntry<'a> {
     /// e.g. `Task` or `Task.{ Task, after }`
     Module(
         ModuleName<'a>,
-        Collection<'a, Loc<ExposesEntry<'a, &'a str>>>,
+        Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
     ),
 
     /// e.g. `pf.Task` or `pf.Task.{ after }` or `pf.{ Task.{ Task, after } }`
     Package(
         &'a str,
         ModuleName<'a>,
-        Collection<'a, Loc<ExposesEntry<'a, &'a str>>>,
+        Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
     ),
-
-    // Spaces
-    SpaceBefore(&'a ImportsEntry<'a>, &'a [CommentOrNewline<'a>]),
-    SpaceAfter(&'a ImportsEntry<'a>, &'a [CommentOrNewline<'a>]),
 }
 
-impl<'a> ExposesEntry<'a, &'a str> {
-    pub fn as_str(&'a self) -> &'a str {
-        use ExposesEntry::*;
-
-        match self {
-            Exposed(string) => string,
-            SpaceBefore(sub_entry, _) | SpaceAfter(sub_entry, _) => sub_entry.as_str(),
-        }
-    }
+/// e.g.
+///
+/// printLine : Str -> Effect {}
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct TypedIdent<'a> {
+    pub ident: Loc<&'a str>,
+    pub spaces_before_colon: &'a [CommentOrNewline<'a>],
+    pub ann: Loc<TypeAnnotation<'a>>,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq)]
-pub enum TypedIdent<'a> {
-    /// e.g.
-    ///
-    /// printLine : Str -> Effect {}
-    Entry {
-        ident: Loc<&'a str>,
-        spaces_before_colon: &'a [CommentOrNewline<'a>],
-        ann: Loc<TypeAnnotation<'a>>,
-    },
-
-    // Spaces
-    SpaceBefore(&'a TypedIdent<'a>, &'a [CommentOrNewline<'a>]),
-    SpaceAfter(&'a TypedIdent<'a>, &'a [CommentOrNewline<'a>]),
+pub struct PackageEntry<'a> {
+    pub shorthand: &'a str,
+    pub spaces_after_shorthand: &'a [CommentOrNewline<'a>],
+    pub package_or_path: Loc<PackageOrPath<'a>>,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum PackageEntry<'a> {
-    Entry {
-        shorthand: &'a str,
-        spaces_after_shorthand: &'a [CommentOrNewline<'a>],
-        package_or_path: Loc<PackageOrPath<'a>>,
-    },
-
-    // Spaces
-    SpaceBefore(&'a PackageEntry<'a>, &'a [CommentOrNewline<'a>]),
-    SpaceAfter(&'a PackageEntry<'a>, &'a [CommentOrNewline<'a>]),
-}
-
-impl<'a> Spaceable<'a> for PackageEntry<'a> {
-    fn before(&'a self, spaces: &'a [CommentOrNewline<'a>]) -> Self {
-        PackageEntry::SpaceBefore(self, spaces)
-    }
-    fn after(&'a self, spaces: &'a [CommentOrNewline<'a>]) -> Self {
-        PackageEntry::SpaceAfter(self, spaces)
-    }
-}
-
-pub fn package_entry<'a>() -> impl Parser<'a, PackageEntry<'a>, EPackageEntry<'a>> {
+pub fn package_entry<'a>() -> impl Parser<'a, Spaced<'a, PackageEntry<'a>>, EPackageEntry<'a>> {
     move |arena, state| {
         // You may optionally have a package shorthand,
         // e.g. "uc" in `uc: roc/unicode 1.0.0`
@@ -293,19 +245,19 @@ pub fn package_entry<'a>() -> impl Parser<'a, PackageEntry<'a>, EPackageEntry<'a
         .parse(arena, state)?;
 
         let entry = match opt_shorthand {
-            Some((shorthand, spaces_after_shorthand)) => PackageEntry::Entry {
+            Some((shorthand, spaces_after_shorthand)) => PackageEntry {
                 shorthand,
                 spaces_after_shorthand,
                 package_or_path,
             },
-            None => PackageEntry::Entry {
+            None => PackageEntry {
                 shorthand: "",
                 spaces_after_shorthand: &[],
                 package_or_path,
             },
         };
 
-        Ok((MadeProgress, entry, state))
+        Ok((MadeProgress, Spaced::Item(entry), state))
     }
 }