Go deeper on UnqualifiedIdent

src/can/expr.rs

@@ -134,6 +134,8 @@ pub fn canonicalize_expr(
                 // let mut branch_cons = Vec::with_capacity(branches.len());
                 let mut field_map = SendMap::default();
                 let mut output = Output::default();
+                let record_var = panic!("TODO record_var");
+                let constraint = panic!("TODO constraint");
 
                 for loc_field in fields.iter() {
                     let (label, field_expr, field_out, field_con) = canonicalize_field(
@@ -146,7 +148,7 @@ pub fn canonicalize_expr(
                         loc_field.region,
                     );
 
-                    output.references = output.references.union(field_out);
+                    output.references = output.references.union(field_out.references);
                 }
 
                 (Record(record_var, field_map), output, constraint)
@@ -1101,7 +1103,7 @@ fn canonicalize_field<'a>(
     env: &mut Env,
     var_store: &VarStore,
     scope: &mut Scope,
-    field_map: SendMap<Lowercase, Expr>,
+    field_map: SendMap<Lowercase, Located<Expr>>,
     field: &'a ast::AssignedField<'a, ast::Expr<'a>>,
     region: Region,
 ) -> (Lowercase, Located<Expr>, Output, Constraint) {
@@ -1110,6 +1112,8 @@ fn canonicalize_field<'a>(
     match field {
         // Both a label and a value, e.g. `{ name: "blah" }`
         LabeledValue(label, _, loc_expr) => {
+            let expected = panic!("TODO expected");
+            let label = panic!("TODO label");
             let (loc_can_expr, output, constraint) = canonicalize_expr(
                 rigids,
                 env,

src/fmt/expr.rs

@@ -227,7 +227,7 @@ pub fn fmt_field<'a>(
                 newline(buf, indent);
             }
 
-            buf.push_str(name.value);
+            buf.push_str(name.value.into());
 
             if !spaces.is_empty() {
                 fmt_spaces(buf, spaces.iter(), indent);
@@ -242,7 +242,7 @@ pub fn fmt_field<'a>(
                 newline(buf, indent);
             }
 
-            buf.push_str(name.value);
+            buf.push_str(name.value.into());
         }
         AssignedField::SpaceBefore(sub_expr, spaces) => {
             fmt_comments_only(buf, spaces.iter(), indent);

src/parse/mod.rs

@@ -346,15 +346,15 @@ pub fn assigned_field_to_pattern<'a>(
                 value: pattern,
             });
             if spaces.is_empty() {
-                Pattern::RecordField(name.value, result)
+                Pattern::RecordField(name.value.into(), result)
             } else {
                 Pattern::SpaceAfter(
-                    arena.alloc(Pattern::RecordField(name.value, result)),
+                    arena.alloc(Pattern::RecordField(name.value.into(), result)),
                     spaces,
                 )
             }
         }
-        AssignedField::LabelOnly(name) => Pattern::Identifier(name.value),
+        AssignedField::LabelOnly(name) => Pattern::Identifier(name.value.into()),
         AssignedField::SpaceBefore(nested, spaces) => Pattern::SpaceBefore(
             arena.alloc(assigned_field_to_pattern(arena, nested)?),
             spaces,

src/parse/parser.rs

@@ -827,9 +827,11 @@ macro_rules! record_field {
             'a,
             $crate::parse::ast::AssignedField<'a, _>,
         > {
+            use $crate::ident::UnqualifiedIdent;
             use $crate::parse::ast::AssignedField::*;
             use $crate::parse::blankspace::{space0, space0_before};
             use $crate::parse::ident::lowercase_ident;
+            use $crate::region::Located;
 
             // You must have a field name, e.g. "email"
             let (loc_label, state) = loc!(lowercase_ident()).parse(arena, state)?;
@@ -843,14 +845,30 @@ macro_rules! record_field {
             .parse(arena, state)?;
 
             let answer = match opt_loc_val {
-                Some(loc_val) => LabeledValue(loc_label, spaces, arena.alloc(loc_val)),
+                Some(loc_val) => LabeledValue(
+                    Located {
+                        value: UnqualifiedIdent::new(loc_label.value),
+                        region: loc_label.region,
+                    },
+                    spaces,
+                    arena.alloc(loc_val),
+                ),
                 // If no value was provided, record it as a Var.
                 // Canonicalize will know what to do with a Var later.
                 None => {
                     if !spaces.is_empty() {
-                        SpaceAfter(arena.alloc(LabelOnly(loc_label)), spaces)
+                        SpaceAfter(
+                            arena.alloc(LabelOnly(Located {
+                                value: UnqualifiedIdent::new(loc_label.value),
+                                region: loc_label.region,
+                            })),
+                            spaces,
+                        )
                     } else {
-                        LabelOnly(loc_label)
+                        LabelOnly(Located {
+                            value: UnqualifiedIdent::new(loc_label.value),
+                            region: loc_label.region,
+                        })
                     }
                 }
             };