Use Collection in Expr::Record and related places

compiler/parse/src/ast.rs

@@ -25,6 +25,18 @@ impl<'a, T> Collection<'a, T> {
             final_comments: &[],
         }
     }
+
+    pub fn iter(&self) -> impl Iterator<Item = &'a T> {
+        self.items.iter()
+    }
+
+    pub fn len(&self) -> usize {
+        self.items.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.items.is_empty()
+    }
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -122,14 +134,10 @@ pub enum Expr<'a> {
 
     RecordUpdate {
         update: &'a Loc<Expr<'a>>,
-        fields: &'a [Loc<AssignedField<'a, Expr<'a>>>],
-        final_comments: &'a &'a [CommentOrNewline<'a>],
+        fields: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
     },
 
-    Record {
-        fields: &'a [Loc<AssignedField<'a, Expr<'a>>>],
-        final_comments: &'a [CommentOrNewline<'a>],
-    },
+    Record(Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>),
 
     // Lookups
     Var {
@@ -257,7 +265,6 @@ pub enum TypeAnnotation<'a> {
         /// The row type variable in an open record, e.g. the `r` in `{ name: Str }r`.
         /// This is None if it's a closed record annotation like `{ name: Str }`.
         ext: Option<&'a Loc<TypeAnnotation<'a>>>,
-        // final_comments: &'a [CommentOrNewline<'a>],
     },
 
     /// A tag union, e.g. `[
@@ -357,10 +364,11 @@ pub enum Pattern<'a> {
     GlobalTag(&'a str),
     PrivateTag(&'a str),
     Apply(&'a Loc<Pattern<'a>>, &'a [Loc<Pattern<'a>>]),
+
     /// This is Loc<Pattern> rather than Loc<str> so we can record comments
     /// around the destructured names, e.g. { x ### x does stuff ###, y }
     /// In practice, these patterns will always be Identifier
-    RecordDestructure(&'a [Loc<Pattern<'a>>]),
+    RecordDestructure(Collection<'a, Loc<Pattern<'a>>>),
 
     /// A required field pattern, e.g. { x: Just 0 } -> ...
     /// Can only occur inside of a RecordDestructure

compiler/parse/src/expr.rs

@@ -1,4 +1,6 @@
-use crate::ast::{AssignedField, CommentOrNewline, Def, Expr, Pattern, Spaceable, TypeAnnotation};
+use crate::ast::{
+    AssignedField, Collection, CommentOrNewline, Def, Expr, Pattern, Spaceable, TypeAnnotation,
+};
 use crate::blankspace::{space0_after_e, space0_around_ee, space0_before_e, space0_e};
 use crate::ident::{lowercase_ident, parse_ident, Ident};
 use crate::keyword;
@@ -1446,10 +1448,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
 
         Expr::ParensAround(sub_expr) => expr_to_pattern_help(arena, sub_expr),
 
-        Expr::Record {
-            fields,
-            final_comments: _,
-        } => {
+        Expr::Record(fields) => {
             let mut loc_patterns = Vec::with_capacity_in(fields.len(), arena);
 
             for loc_assigned_field in fields.iter() {
@@ -1459,7 +1458,10 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
                 loc_patterns.push(Located { region, value });
             }
 
-            Ok(Pattern::RecordDestructure(loc_patterns.into_bump_slice()))
+            Ok(Pattern::RecordDestructure(Collection {
+                items: loc_patterns.into_bump_slice(),
+                final_comments: fields.final_comments,
+            }))
         }
 
         Expr::Float(string) => Ok(Pattern::FloatLiteral(string)),
@@ -2312,13 +2314,15 @@ fn record_literal_help<'a>(min_indent: u16) -> impl Parser<'a, Expr<'a>, EExpr<'
             let mut value = match opt_update {
                 Some(update) => Expr::RecordUpdate {
                     update: &*arena.alloc(update),
-                    fields: loc_assigned_fields_with_comments.value.0.into_bump_slice(),
-                    final_comments: arena.alloc(loc_assigned_fields_with_comments.value.1),
+                    fields: Collection {
+                        items: loc_assigned_fields_with_comments.value.0.into_bump_slice(),
+                        final_comments: arena.alloc(loc_assigned_fields_with_comments.value.1),
+                    },
                 },
-                None => Expr::Record {
-                    fields: loc_assigned_fields_with_comments.value.0.into_bump_slice(),
+                None => Expr::Record(Collection {
+                    items: loc_assigned_fields_with_comments.value.0.into_bump_slice(),
                     final_comments: loc_assigned_fields_with_comments.value.1,
-                },
+                }),
             };
 
             // there can be field access, e.g. `{ x : 4 }.x`

compiler/parse/src/pattern.rs

@@ -331,10 +331,7 @@ fn record_pattern_help<'a>(min_indent: u16) -> impl Parser<'a, Pattern<'a>, PRec
         )
         .parse(arena, state)?;
 
-        // TODO
-        let _unused = fields.final_comments;
-
-        let result = Pattern::RecordDestructure(fields.items);
+        let result = Pattern::RecordDestructure(fields);
 
         Ok((MadeProgress, result, state))
     }