Format ingested file with optional annotation

crates/compiler/fmt/src/def.rs

@@ -6,8 +6,8 @@ use crate::spaces::{fmt_default_newline, fmt_default_spaces, fmt_spaces, INDENT}
 use crate::Buf;
 use roc_parse::ast::{
     AbilityMember, Defs, Expr, ExtractSpaces, ImportAlias, ImportAsKeyword, ImportExposingKeyword,
-    ImportedModuleName, IngestedFileImport, ModuleImport, Pattern, Spaces, StrLiteral,
-    TypeAnnotation, TypeDef, TypeHeader, ValueDef,
+    ImportedModuleName, IngestedFileAnnotation, IngestedFileImport, ModuleImport, Pattern, Spaces,
+    StrLiteral, TypeAnnotation, TypeDef, TypeHeader, ValueDef,
 };
 use roc_parse::header::Keyword;
 use roc_region::all::Loc;
@@ -257,8 +257,9 @@ impl<'a> Formattable for IngestedFileImport<'a> {
             before_path,
             path: _,
             name,
+            annotation,
         } = self;
-        !before_path.is_empty() || name.is_multiline()
+        !before_path.is_empty() || name.keyword.is_multiline() || annotation.is_multiline()
     }
 
     fn format_with_options(
@@ -272,6 +273,7 @@ impl<'a> Formattable for IngestedFileImport<'a> {
             before_path,
             path,
             name,
+            annotation,
         } = self;
 
         buf.indent(indent);
@@ -281,7 +283,11 @@ impl<'a> Formattable for IngestedFileImport<'a> {
 
         fmt_default_spaces(buf, before_path, indent);
         fmt_str_literal(buf, path.value, indent);
-        name.format(buf, indent);
+
+        name.keyword.format(buf, indent);
+        buf.push_str(&name.item.value);
+
+        annotation.format(buf, indent);
     }
 }
 
@@ -361,6 +367,34 @@ impl Formattable for ImportExposingKeyword {
     }
 }
 
+impl<'a> Formattable for IngestedFileAnnotation<'a> {
+    fn is_multiline(&self) -> bool {
+        let Self {
+            before_colon,
+            annotation,
+        } = self;
+        !before_colon.is_empty() || annotation.is_multiline()
+    }
+
+    fn format_with_options(
+        &self,
+        buf: &mut Buf,
+        _parens: Parens,
+        _newlines: Newlines,
+        indent: u16,
+    ) {
+        let Self {
+            before_colon,
+            annotation,
+        } = self;
+
+        fmt_default_spaces(buf, before_colon, indent);
+        buf.push_str(":");
+        buf.spaces(1);
+        annotation.format(buf, indent);
+    }
+}
+
 impl<'a> Formattable for ValueDef<'a> {
     fn is_multiline(&self) -> bool {
         use roc_parse::ast::ValueDef::*;

crates/compiler/fmt/src/spaces.rs

@@ -5,9 +5,10 @@ use roc_parse::{
     ast::{
         AbilityImpls, AbilityMember, AssignedField, Collection, CommentOrNewline, Defs, Expr,
         Header, Implements, ImplementsAbilities, ImplementsAbility, ImplementsClause, ImportAlias,
-        ImportAsKeyword, ImportExposingKeyword, ImportedModuleName, IngestedFileImport, Module,
-        ModuleImport, Pattern, PatternAs, RecordBuilderField, Spaced, Spaces, StrLiteral,
-        StrSegment, Tag, TypeAnnotation, TypeDef, TypeHeader, ValueDef, WhenBranch,
+        ImportAsKeyword, ImportExposingKeyword, ImportedModuleName, IngestedFileAnnotation,
+        IngestedFileImport, Module, ModuleImport, Pattern, PatternAs, RecordBuilderField, Spaced,
+        Spaces, StrLiteral, StrSegment, Tag, TypeAnnotation, TypeDef, TypeHeader, ValueDef,
+        WhenBranch,
     },
     header::{
         AppHeader, ExposedName, HostedHeader, ImportsEntry, KeywordItem, ModuleHeader, ModuleName,
@@ -600,6 +601,7 @@ impl<'a> RemoveSpaces<'a> for IngestedFileImport<'a> {
             before_path: &[],
             path: self.path.remove_spaces(arena),
             name: self.name.remove_spaces(arena),
+            annotation: self.annotation.remove_spaces(arena),
         }
     }
 }
@@ -631,6 +633,15 @@ impl<'a> RemoveSpaces<'a> for ImportExposingKeyword {
     }
 }
 
+impl<'a> RemoveSpaces<'a> for IngestedFileAnnotation<'a> {
+    fn remove_spaces(&self, arena: &'a Bump) -> Self {
+        IngestedFileAnnotation {
+            before_colon: &[],
+            annotation: self.annotation.remove_spaces(arena),
+        }
+    }
+}
+
 impl<'a> RemoveSpaces<'a> for Implements<'a> {
     fn remove_spaces(&self, _arena: &'a Bump) -> Self {
         Implements::Implements