Remove OptionalField from AST

src/can/annotation.rs

@@ -118,11 +118,6 @@ fn can_assigned_field<'a>(
             let label = Lowercase::from(field_name.value);
             field_types.insert(label, field_type);
         }
-        OptionalField(field_name, _, annotation) => {
-            let field_type = can_annotation_help(&annotation.value, var_store, rigids);
-            let label = Lowercase::from(field_name.value);
-            field_types.insert(label, field_type);
-        }
         LabelOnly(loc_field_name) => {
             // Interpret { a, b } as { a : a, b : b }
             let field_name = Lowercase::from(loc_field_name.value);

src/can/expr.rs

@@ -1011,8 +1011,6 @@ fn canonicalize_field<'a>(
             )
         }
 
-        OptionalField(_, _, _) => panic!("invalid in expressions"),
-
         // A label with no value, e.g. `{ name }` (this is sugar for { name: name })
         LabelOnly(_) => {
             panic!("Somehow a LabelOnly record field was not desugared!");

src/can/operator.rs

@@ -298,7 +298,6 @@ fn desugar_field<'a>(
             spaces,
             desugar_expr(arena, loc_expr),
         ),
-        OptionalField(_, _, _) => panic!("invalid in expressions"),
         LabelOnly(loc_str) => {
             // Desugar { x } into { x: x }
             let loc_expr = Located {

src/fmt/expr.rs

@@ -246,22 +246,6 @@ pub fn fmt_field<'a>(
             buf.push(' ');
             fmt_expr(buf, &value.value, indent, apply_needs_parens, true);
         }
-        OptionalField(name, spaces, value) => {
-            if is_multiline {
-                newline(buf, indent);
-            }
-
-            buf.push_str(name.value);
-            buf.push('?');
-
-            if !spaces.is_empty() {
-                fmt_spaces(buf, spaces.iter(), indent);
-            }
-
-            buf.push(':');
-            buf.push(' ');
-            fmt_expr(buf, &value.value, indent, apply_needs_parens, true);
-        }
         LabelOnly(name) => {
             if is_multiline {
                 newline(buf, indent);
@@ -406,7 +390,6 @@ pub fn is_multiline_field<'a, Val>(field: &'a AssignedField<'a, Val>) -> bool {
 
     match field {
         LabeledValue(_, spaces, _) => !spaces.is_empty(),
-        OptionalField(_, spaces, _) => !spaces.is_empty(),
         LabelOnly(_) => false,
         AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => true,
         Malformed(text) => text.chars().any(|c| c == '\n'),

src/parse/ast.rs

@@ -243,9 +243,6 @@ pub enum AssignedField<'a, Val> {
     // Both a label and a value, e.g. `{ name: "blah" }`
     LabeledValue(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Val>),
 
-    // An optional field, e.g. `{ name? : String }`. Only for types
-    OptionalField(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Val>),
-
     // A label with no value, e.g. `{ name }` (this is sugar for { name: name })
     LabelOnly(Loc<&'a str>),
 

src/parse/mod.rs

@@ -359,7 +359,6 @@ pub fn assigned_expr_field_to_pattern<'a>(
                 )
             }
         }
-        AssignedField::OptionalField(_, _, _) => panic!("invalid in literals"),
         AssignedField::LabelOnly(name) => Pattern::Identifier(name.value),
         AssignedField::SpaceBefore(nested, spaces) => Pattern::SpaceBefore(
             arena.alloc(assigned_expr_field_to_pattern(arena, nested)?),
@@ -400,9 +399,6 @@ pub fn assigned_pattern_field_to_pattern<'a>(
                 )
             }
         }
-        AssignedField::OptionalField(_, _, _) => {
-            panic!("invalid as a pattern");
-        }
         AssignedField::LabelOnly(name) => Located::at(name.region, Pattern::Identifier(name.value)),
         AssignedField::SpaceBefore(nested, spaces) => {
             let can_nested = assigned_pattern_field_to_pattern(arena, nested, backup_region)?;

src/parse/parser.rs

@@ -905,9 +905,6 @@ macro_rules! record_field {
             // You must have a field name, e.g. "email"
             let (loc_label, state) = loc!(lowercase_ident()).parse(arena, state)?;
 
-            let (opt_field, state) =
-                $crate::parse::parser::optional(char('?')).parse(arena, state)?;
-
             let (spaces, state) = space0($min_indent).parse(arena, state)?;
             // Having a value is optional; both `{ email }` and `{ email: blah }` work.
             // (This is true in both literals and types.)
@@ -917,27 +914,24 @@ macro_rules! record_field {
             ))
             .parse(arena, state)?;
 
-            let answer = match (opt_loc_val, opt_field) {
-                (Some(loc_val), None) => LabeledValue(loc_label, spaces, arena.alloc(loc_val)),
-                (Some(loc_val), Some(_)) => OptionalField(loc_label, spaces, arena.alloc(loc_val)),
+            let answer = match opt_loc_val {
+                Some(loc_val) => LabeledValue(loc_label, 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, None) => {
+                None => {
                     if !spaces.is_empty() {
                         SpaceAfter(arena.alloc(LabelOnly(loc_label)), spaces)
                     } else {
                         LabelOnly(loc_label)
                     }
                 }
-                (None, Some(_)) => {
-                    panic!("TODO should `{ x? }` be valid? realistically, how of often does `{ a : a }` occur in a type?");
-                }
             };
 
             Ok((answer, state))
         }
     };
 }
+
 #[macro_export]
 macro_rules! record_without_update {
     ($val_parser:expr, $min_indent:expr) => {