Merge branch 'trunk' into refactor-builtin-list-drop

compiler/can/src/annotation.rs

@@ -417,7 +417,7 @@ fn can_annotation_help(
         TagUnion { tags, ext, .. } => {
             let tag_types = can_tags(
                 env,
-                tags,
+                tags.items,
                 region,
                 scope,
                 var_store,

compiler/can/src/builtins.rs

@@ -69,6 +69,7 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option<Def>
         STR_REPEAT => str_repeat,
         STR_TRIM => str_trim,
         STR_TRIM_LEFT => str_trim_left,
+        STR_TRIM_RIGHT => str_trim_right,
         LIST_LEN => list_len,
         LIST_GET => list_get,
         LIST_SET => list_set,
@@ -1295,6 +1296,11 @@ fn str_trim_left(symbol: Symbol, var_store: &mut VarStore) -> Def {
     lowlevel_1(symbol, LowLevel::StrTrimLeft, var_store)
 }
 
+/// Str.trimRight : Str -> Str
+fn str_trim_right(symbol: Symbol, var_store: &mut VarStore) -> Def {
+    lowlevel_1(symbol, LowLevel::StrTrimRight, var_store)
+}
+
 /// Str.repeat : Str, Nat -> Str
 fn str_repeat(symbol: Symbol, var_store: &mut VarStore) -> Def {
     let str_var = var_store.fresh();

compiler/can/src/expr.rs

@@ -228,14 +228,11 @@ pub fn canonicalize_expr<'a>(
 
             (answer, Output::default())
         }
-        ast::Expr::Record {
-            fields,
-            final_comments: _,
-        } => {
+        ast::Expr::Record(fields) => {
             if fields.is_empty() {
                 (EmptyRecord, Output::default())
             } else {
-                match canonicalize_fields(env, var_store, scope, region, fields) {
+                match canonicalize_fields(env, var_store, scope, region, fields.items) {
                     Ok((can_fields, output)) => (
                         Record {
                             record_var: var_store.fresh(),
@@ -261,12 +258,11 @@ pub fn canonicalize_expr<'a>(
         ast::Expr::RecordUpdate {
             fields,
             update: loc_update,
-            final_comments: _,
         } => {
             let (can_update, update_out) =
                 canonicalize_expr(env, var_store, scope, loc_update.region, &loc_update.value);
             if let Var(symbol) = &can_update.value {
-                match canonicalize_fields(env, var_store, scope, region, fields) {
+                match canonicalize_fields(env, var_store, scope, region, fields.items) {
                     Ok((can_fields, mut output)) => {
                         output.references = output.references.union(update_out.references);
 
@@ -307,9 +303,7 @@ pub fn canonicalize_expr<'a>(
             }
         }
         ast::Expr::Str(literal) => flatten_str_literal(env, var_store, scope, literal),
-        ast::Expr::List {
-            items: loc_elems, ..
-        } => {
+        ast::Expr::List(loc_elems) => {
             if loc_elems.is_empty() {
                 (
                     List {

compiler/can/src/operator.rs

@@ -144,77 +144,46 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Located<Expr<'a>>) -> &'a
 
             arena.alloc(Located { region, value })
         }
-        List {
-            items,
-            final_comments,
-        } => {
+        List(items) => {
             let mut new_items = Vec::with_capacity_in(items.len(), arena);
 
             for item in items.iter() {
                 new_items.push(desugar_expr(arena, item));
             }
             let new_items = new_items.into_bump_slice();
-            let value: Expr<'a> = List {
-                items: new_items,
-                final_comments,
-            };
+            let value: Expr<'a> = List(items.replace_items(new_items));
 
             arena.alloc(Located {
                 region: loc_expr.region,
                 value,
             })
         }
-        Record {
-            fields,
-            final_comments,
-        } => {
-            let mut new_fields = Vec::with_capacity_in(fields.len(), arena);
-
-            for field in fields.iter() {
+        Record(fields) => arena.alloc(Located {
+            region: loc_expr.region,
+            value: Record(fields.map_items(arena, |field| {
                 let value = desugar_field(arena, &field.value);
-
-                new_fields.push(Located {
+                Located {
                     value,
                     region: field.region,
-                });
-            }
+                }
+            })),
+        }),
 
-            let new_fields = new_fields.into_bump_slice();
-
-            arena.alloc(Located {
-                region: loc_expr.region,
-                value: Record {
-                    fields: new_fields,
-                    final_comments,
-                },
-            })
-        }
-
-        RecordUpdate {
-            fields,
-            update,
-            final_comments,
-        } => {
+        RecordUpdate { fields, update } => {
             // NOTE the `update` field is always a `Var { .. }` and does not need to be desugared
-            let mut new_fields = Vec::with_capacity_in(fields.len(), arena);
-
-            for field in fields.iter() {
+            let new_fields = fields.map_items(arena, |field| {
                 let value = desugar_field(arena, &field.value);
-
-                new_fields.push(Located {
+                Located {
                     value,
                     region: field.region,
-                });
-            }
-
-            let new_fields = new_fields.into_bump_slice();
+                }
+            });
 
             arena.alloc(Located {
                 region: loc_expr.region,
                 value: RecordUpdate {
                     update: *update,
                     fields: new_fields,
-                    final_comments,
                 },
             })
         }

compiler/can/src/pattern.rs

@@ -246,7 +246,7 @@ pub fn canonicalize_pattern<'a>(
             let mut destructs = Vec::with_capacity(patterns.len());
             let mut opt_erroneous = None;
 
-            for loc_pattern in *patterns {
+            for loc_pattern in patterns.iter() {
                 match loc_pattern.value {
                     Identifier(label) => {
                         match scope.introduce(