Start tracking position of trailing commas

compiler-core/src/format.rs

···
     module_comments: Vec<Comment<'a>>,
     empty_lines: &'a [u32],
     new_lines: &'a [u32],
+    trailing_commas: &'a [u32],
 }
 
 impl<'a> Intermediate<'a> {
···
                 .map(|span| Comment::from((span, src)))
                 .collect(),
             new_lines: &extra.new_lines,
+            trailing_commas: &extra.trailing_commas,
         }
     }
 }
···
     module_comments: &'a [Comment<'a>],
     empty_lines: &'a [u32],
     new_lines: &'a [u32],
+    trailing_commas: &'a [u32],
 }
 
 impl<'comments> Formatter<'comments> {
···
             module_comments: &extra.module_comments,
             empty_lines: extra.empty_lines,
             new_lines: extra.new_lines,
+            trailing_commas: extra.trailing_commas,
         }
     }
 

compiler-core/src/parse.rs

···
         sep: Option<&Token>,
     ) -> Result<(Vec<A>, bool), ParseError> {
         let mut results = vec![];
-        let mut ends_with_sep = false;
+        let mut final_separator = None;
         while let Some(result) = parser(self)? {
             results.push(result);
             if let Some(sep) = sep {
-                if self.maybe_one(sep).is_none() {
-                    ends_with_sep = false;
-                    break;
+                if let Some(separator) = self.maybe_one(sep) {
+                    final_separator = Some(separator);
                 } else {
-                    ends_with_sep = true;
+                    final_separator = None;
+                    break;
                 }
+
                 // Helpful error if extra separator
                 if let Some((start, end)) = self.maybe_one(sep) {
                     return parse_error(ParseErrorType::ExtraSeparator, SrcSpan { start, end });
···
             }
         }
 
-        Ok((results, ends_with_sep))
+        // If the sequence ends with a trailing comma we want to keep track of
+        // its position.
+        if let (Some(Token::Comma), Some((_, end))) = (sep, final_separator) {
+            self.extra.trailing_commas.push(end)
+        };
+
+        Ok((results, final_separator.is_some()))
     }
 
     // If next token is a Name, consume it and return relevant info, otherwise, return none

compiler-core/src/parse/extra.rs

···
     pub comments: Vec<SrcSpan>,
     pub empty_lines: Vec<u32>,
     pub new_lines: Vec<u32>,
+    pub trailing_commas: Vec<u32>,
 }
 
 impl ModuleExtra {

compiler-core/src/parse/snapshots/gleam_core__parse__tests__const_string_concat.snap

···
             20,
             51,
         ],
+        trailing_commas: [],
     },
 }

compiler-core/src/parse/snapshots/gleam_core__parse__tests__deprecation_attribute_on_type_variant.snap

···
             59,
             61,
         ],
+        trailing_commas: [],
     },
 }

compiler-core/src/parse/snapshots/gleam_core__parse__tests__import_type.snap

···
         comments: [],
         empty_lines: [],
         new_lines: [],
+        trailing_commas: [],
     },
 }

compiler-core/src/parse/snapshots/gleam_core__parse__tests__record_access_no_label.snap

···
             73,
             75,
         ],
+        trailing_commas: [],
     },
 }