Upgrade hosted header in the style module header

crates/compiler/parse/src/ast.rs

@@ -172,7 +172,14 @@ impl<'a> Header<'a> {
                 }),
                 Self::header_imports_to_defs(arena, header.old_imports),
             ),
-            Header::Package(_) | Header::Platform(_) | Header::Hosted(_) => (self, Defs::default()),
+            Header::Hosted(header) => (
+                Header::Hosted(HostedHeader {
+                    old_imports: None,
+                    ..header
+                }),
+                Self::header_imports_to_defs(arena, header.old_imports),
+            ),
+            Header::Package(_) | Header::Platform(_) => (self, Defs::default()),
         };
 
         (header, defs)

crates/compiler/parse/src/header.rs

@@ -103,7 +103,7 @@ pub fn header<'a>() -> impl Parser<'a, SpacesBefore<'a, Header<'a>>, EHeader<'a>
             map(
                 skip_first(
                     keyword("hosted", EHeader::Start),
-                    increment_min_indent(hosted_header())
+                    increment_min_indent(one_of![hosted_header(), old_hosted_header()])
                 ),
                 Header::Hosted
             ),
@@ -184,15 +184,38 @@ fn imports_none_if_empty(value: ImportsKeywordItem<'_>) -> Option<ImportsKeyword
 
 #[inline(always)]
 fn hosted_header<'a>() -> impl Parser<'a, HostedHeader<'a>, EHeader<'a>> {
-    record!(HostedHeader {
-        before_name: space0_e(EHeader::IndentStart),
-        name: loc(module_name_help(EHeader::ModuleName)),
-        exposes: specialize_err(EHeader::Exposes, exposes_values_kw()),
-        imports: specialize_err(EHeader::Imports, imports()),
-    })
+    map(
+        and(
+            backtrackable(space0_e(EHeader::IndentStart)),
+            specialize_err(EHeader::Exposes, exposes_list()),
+        ),
+        |(before_exposes, exposes)| HostedHeader {
+            before_exposes,
+            exposes,
+            old_imports: None,
+        },
+    )
     .trace("hosted_header")
 }
 
+#[inline(always)]
+fn old_hosted_header<'a>() -> impl Parser<'a, HostedHeader<'a>, EHeader<'a>> {
+    map(
+        record!(OldHostedHeader {
+            before_name: space0_e(EHeader::IndentStart),
+            name: loc(module_name_help(EHeader::ModuleName)),
+            exposes: specialize_err(EHeader::Exposes, exposes_values_kw()),
+            imports: specialize_err(EHeader::Imports, imports()),
+        }),
+        |old_hosted| HostedHeader {
+            before_exposes: old_hosted.before_name,
+            exposes: old_hosted.exposes.item,
+            old_imports: Some(old_hosted.imports),
+        },
+    )
+    .trace("old_hosted_header")
+}
+
 fn chomp_module_name(buffer: &[u8]) -> Result<&str, Progress> {
     use encode_unicode::CharExt;
 
@@ -1196,6 +1219,15 @@ pub type ImportsCollection<'a> = Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct HostedHeader<'a> {
+    pub before_exposes: &'a [CommentOrNewline<'a>],
+    pub exposes: Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>,
+
+    // Keeping this so we can format old interface header into module headers
+    pub old_imports: Option<KeywordItem<'a, ImportsKeyword, ImportsCollection<'a>>>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct OldHostedHeader<'a> {
     pub before_name: &'a [CommentOrNewline<'a>],
     pub name: Loc<ModuleName<'a>>,
     pub exposes: KeywordItem<'a, ExposesKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,

crates/compiler/parse/src/normalize.rs

@@ -172,10 +172,9 @@ impl<'a> Normalize<'a> for Header<'a> {
                 provides: header.provides.normalize(arena),
             }),
             Header::Hosted(header) => Header::Hosted(HostedHeader {
-                before_name: &[],
-                name: header.name.normalize(arena),
+                before_exposes: &[],
                 exposes: header.exposes.normalize(arena),
-                imports: header.imports.normalize(arena),
+                old_imports: None,
             }),
         }
     }