Merge pull request #7176 from JRI98/unused_malformed

Remove unused malformed related variants

crates/compiler/can/src/annotation.rs

@@ -482,7 +482,6 @@ pub fn find_type_def_symbols(
                         AssignedField::LabelOnly(_) => {}
                         AssignedField::SpaceBefore(inner, _)
                         | AssignedField::SpaceAfter(inner, _) => inner_stack.push(inner),
-                        AssignedField::Malformed(_) => {}
                     }
                 }
 
@@ -507,7 +506,6 @@ pub fn find_type_def_symbols(
                         Tag::SpaceBefore(inner, _) | Tag::SpaceAfter(inner, _) => {
                             inner_stack.push(inner)
                         }
-                        Tag::Malformed(_) => {}
                     }
                 }
 
@@ -1355,7 +1353,7 @@ fn can_assigned_fields<'a>(
     // field names we've seen so far in this record
     let mut seen = std::collections::HashMap::with_capacity(fields.len());
 
-    'outer: for loc_field in fields.iter() {
+    for loc_field in fields.iter() {
         let mut field = &loc_field.value;
 
         // use this inner loop to unwrap the SpaceAfter/SpaceBefore
@@ -1430,12 +1428,6 @@ fn can_assigned_fields<'a>(
                     field = nested;
                     continue 'inner;
                 }
-                Malformed(string) => {
-                    malformed(env, region, string);
-
-                    // completely skip this element, advance to the next tag
-                    continue 'outer;
-                }
             }
         };
 
@@ -1522,7 +1514,7 @@ fn can_tags<'a>(
     // tag names we've seen so far in this tag union
     let mut seen = std::collections::HashMap::with_capacity(tags.len());
 
-    'outer: for loc_tag in tags.iter() {
+    for loc_tag in tags.iter() {
         let mut tag = &loc_tag.value;
 
         // use this inner loop to unwrap the SpaceAfter/SpaceBefore
@@ -1561,12 +1553,6 @@ fn can_tags<'a>(
                     tag = nested;
                     continue 'inner;
                 }
-                Tag::Malformed(string) => {
-                    malformed(env, region, string);
-
-                    // completely skip this element, advance to the next tag
-                    continue 'outer;
-                }
             }
         };
 

crates/compiler/can/src/def.rs

@@ -715,10 +715,6 @@ fn canonicalize_claimed_ability_impl<'a>(
             });
             Err(())
         }
-        AssignedField::Malformed(_) => {
-            // An error will already have been reported
-            Err(())
-        }
         AssignedField::SpaceBefore(_, _)
         | AssignedField::SpaceAfter(_, _)
         | AssignedField::IgnoredValue(_, _, _) => {

crates/compiler/can/src/desugar.rs

@@ -407,7 +407,6 @@ pub fn desugar_expr<'a>(
         | AccessorFunction(_)
         | Underscore { .. }
         | MalformedIdent(_, _)
-        | MalformedClosure
         | MalformedSuffixed(..)
         | PrecedenceConflict { .. }
         | EmptyRecordBuilder(_)
@@ -712,7 +711,6 @@ pub fn desugar_expr<'a>(
                     AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => {
                         unreachable!("Should have been desugared in `desugar_field`")
                     }
-                    AssignedField::Malformed(_name) => continue,
                 };
 
                 field_data.push(FieldData {
@@ -1316,8 +1314,6 @@ fn desugar_field<'a>(
         }
         SpaceBefore(field, _spaces) => desugar_field(env, scope, field),
         SpaceAfter(field, _spaces) => desugar_field(env, scope, field),
-
-        Malformed(string) => Malformed(string),
     }
 }
 

crates/compiler/can/src/expr.rs

@@ -1391,10 +1391,6 @@ pub fn canonicalize_expr<'a>(
                 Output::default(),
             )
         }
-        ast::Expr::MalformedClosure => {
-            use roc_problem::can::RuntimeError::*;
-            (RuntimeError(MalformedClosure(region)), Output::default())
-        }
         ast::Expr::MalformedIdent(name, bad_ident) => {
             use roc_problem::can::RuntimeError::*;
 
@@ -1976,10 +1972,6 @@ fn canonicalize_field<'a>(
         SpaceBefore(sub_field, _) | SpaceAfter(sub_field, _) => {
             canonicalize_field(env, var_store, scope, sub_field)
         }
-
-        Malformed(_string) => {
-            internal_error!("TODO canonicalize malformed record field");
-        }
     }
 }
 
@@ -2568,8 +2560,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
         | ast::Expr::Underscore(_)
         | ast::Expr::MalformedIdent(_, _)
         | ast::Expr::Tag(_)
-        | ast::Expr::OpaqueRef(_)
-        | ast::Expr::MalformedClosure => true,
+        | ast::Expr::OpaqueRef(_) => true,
         // Newlines are disallowed inside interpolation, and these all require newlines
         ast::Expr::DbgStmt(_, _)
         | ast::Expr::LowLevelDbg(_, _, _)
@@ -2604,7 +2595,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
             | ast::AssignedField::IgnoredValue(_label, loc_comments, loc_val) => {
                 loc_comments.is_empty() && is_valid_interpolation(&loc_val.value)
             }
-            ast::AssignedField::Malformed(_) | ast::AssignedField::LabelOnly(_) => true,
+            ast::AssignedField::LabelOnly(_) => true,
             ast::AssignedField::SpaceBefore(_, _) | ast::AssignedField::SpaceAfter(_, _) => false,
         }),
         ast::Expr::Tuple(fields) => fields
@@ -2655,7 +2646,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
                     | ast::AssignedField::IgnoredValue(_label, loc_comments, loc_val) => {
                         loc_comments.is_empty() && is_valid_interpolation(&loc_val.value)
                     }
-                    ast::AssignedField::Malformed(_) | ast::AssignedField::LabelOnly(_) => true,
+                    ast::AssignedField::LabelOnly(_) => true,
                     ast::AssignedField::SpaceBefore(_, _)
                     | ast::AssignedField::SpaceAfter(_, _) => false,
                 })
@@ -2668,7 +2659,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
                     | ast::AssignedField::IgnoredValue(_label, loc_comments, loc_val) => {
                         loc_comments.is_empty() && is_valid_interpolation(&loc_val.value)
                     }
-                    ast::AssignedField::Malformed(_) | ast::AssignedField::LabelOnly(_) => true,
+                    ast::AssignedField::LabelOnly(_) => true,
                     ast::AssignedField::SpaceBefore(_, _)
                     | ast::AssignedField::SpaceAfter(_, _) => false,
                 })

crates/compiler/fmt/src/annotation.rs

@@ -438,7 +438,6 @@ fn is_multiline_assigned_field_help<T: Formattable>(afield: &AssignedField<'_, T
         | IgnoredValue(_, spaces, ann) => !spaces.is_empty() || ann.value.is_multiline(),
         LabelOnly(_) => false,
         AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => true,
-        Malformed(text) => text.chars().any(|c| c == '\n'),
     }
 }
 
@@ -522,9 +521,6 @@ fn format_assigned_field_help<T>(
             format_assigned_field_help(sub_field, buf, indent, separator_spaces, is_multiline);
             fmt_comments_only(buf, spaces.iter(), NewlineAt::Bottom, indent);
         }
-        Malformed(raw) => {
-            buf.push_str(raw);
-        }
     }
 }
 
@@ -535,7 +531,6 @@ impl<'a> Formattable for Tag<'a> {
         match self {
             Apply { args, .. } => args.iter().any(|arg| arg.value.is_multiline()),
             Tag::SpaceBefore(_, _) | Tag::SpaceAfter(_, _) => true,
-            Malformed(text) => text.chars().any(|c| c == '\n'),
         }
     }
 
@@ -572,10 +567,6 @@ impl<'a> Formattable for Tag<'a> {
                 }
             }
             Tag::SpaceBefore(_, _) | Tag::SpaceAfter(_, _) => unreachable!(),
-            Tag::Malformed(raw) => {
-                buf.indent(indent);
-                buf.push_str(raw);
-            }
         }
     }
 }

crates/compiler/fmt/src/expr.rs

@@ -44,7 +44,6 @@ impl<'a> Formattable for Expr<'a> {
             | Var { .. }
             | Underscore { .. }
             | MalformedIdent(_, _)
-            | MalformedClosure
             | Tag(_)
             | OpaqueRef(_)
             | Crash
@@ -557,7 +556,6 @@ impl<'a> Formattable for Expr<'a> {
                 buf.indent(indent);
                 loc_expr.format_with_options(buf, parens, newlines, indent);
             }
-            MalformedClosure => {}
             PrecedenceConflict { .. } => {}
             EmptyRecordBuilder { .. } => {}
             SingleFieldRecordBuilder { .. } => {}
@@ -1646,9 +1644,6 @@ fn format_assigned_field_multiline<T>(
             format_assigned_field_multiline(buf, sub_field, indent, separator_prefix);
             fmt_comments_only(buf, spaces.iter(), NewlineAt::Top, indent);
         }
-        Malformed(raw) => {
-            buf.push_str(raw);
-        }
     }
 }
 

crates/compiler/load_internal/src/docs.rs

@@ -476,7 +476,7 @@ fn contains_unexposed_type(
                             return true;
                         }
                     }
-                    AssignedField::Malformed(_) | AssignedField::LabelOnly(_) => {
+                    AssignedField::LabelOnly(_) => {
                         // contains no unexposed types, so continue
                     }
                     AssignedField::SpaceBefore(field, _) | AssignedField::SpaceAfter(field, _) => {
@@ -524,9 +524,6 @@ fn contains_unexposed_type(
                             }
                         }
                     }
-                    Tag::Malformed(_) => {
-                        // contains no unexposed types, so continue
-                    }
                     Tag::SpaceBefore(tag, _) | Tag::SpaceAfter(tag, _) => {
                         tags_to_process.push(*tag);
                     }
@@ -728,7 +725,7 @@ fn record_field_to_doc(
         AssignedField::LabelOnly(label) => Some(RecordField::LabelOnly {
             name: label.value.to_string(),
         }),
-        AssignedField::Malformed(_) | AssignedField::IgnoredValue(_, _, _) => None,
+        AssignedField::IgnoredValue(_, _, _) => None,
     }
 }
 
@@ -749,7 +746,6 @@ fn tag_to_doc(in_func_ann: bool, tag: ast::Tag) -> Option<Tag> {
         }),
         ast::Tag::SpaceBefore(&sub_tag, _) => tag_to_doc(in_func_ann, sub_tag),
         ast::Tag::SpaceAfter(&sub_tag, _) => tag_to_doc(in_func_ann, sub_tag),
-        ast::Tag::Malformed(_) => None,
     }
 }
 

crates/compiler/parse/src/ast.rs

@@ -539,7 +539,6 @@ pub enum Expr<'a> {
 
     // Problems
     MalformedIdent(&'a str, crate::ident::BadIdent),
-    MalformedClosure,
     MalformedSuffixed(&'a Loc<Expr<'a>>),
     // Both operators were non-associative, e.g. (True == False == False).
     // We should tell the author to disambiguate by grouping them with parens.
@@ -687,7 +686,6 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
         Expr::SpaceBefore(a, _) => is_expr_suffixed(a),
         Expr::SpaceAfter(a, _) => is_expr_suffixed(a),
         Expr::MalformedIdent(_, _) => false,
-        Expr::MalformedClosure => false,
         Expr::MalformedSuffixed(_) => false,
         Expr::PrecedenceConflict(_) => false,
         Expr::EmptyRecordBuilder(_) => false,
@@ -713,7 +711,6 @@ fn is_assigned_value_suffixed<'a>(value: &AssignedField<'a, Expr<'a>>) -> bool {
         AssignedField::SpaceBefore(a, _) | AssignedField::SpaceAfter(a, _) => {
             is_assigned_value_suffixed(a)
         }
-        AssignedField::Malformed(_) => false,
     }
 }
 
@@ -889,7 +886,7 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
                             | OptionalValue(_, _, loc_val)
                             | IgnoredValue(_, _, loc_val) => break expr_stack.push(&loc_val.value),
                             SpaceBefore(next, _) | SpaceAfter(next, _) => current = *next,
-                            LabelOnly(_) | Malformed(_) => break,
+                            LabelOnly(_) => break,
                         }
                     }
                 }
@@ -1038,7 +1035,6 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
                 | Tag(_)
                 | OpaqueRef(_)
                 | MalformedIdent(_, _)
-                | MalformedClosure
                 | PrecedenceConflict(_)
                 | MalformedSuffixed(_) => { /* terminal */ }
             }
@@ -1614,9 +1610,6 @@ pub enum Tag<'a> {
     // We preserve this for the formatter; canonicalization ignores it.
     SpaceBefore(&'a Tag<'a>, &'a [CommentOrNewline<'a>]),
     SpaceAfter(&'a Tag<'a>, &'a [CommentOrNewline<'a>]),
-
-    /// A malformed tag, which will code gen to a runtime error
-    Malformed(&'a str),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -1639,9 +1632,6 @@ pub enum AssignedField<'a, Val> {
     // We preserve this for the formatter; canonicalization ignores it.
     SpaceBefore(&'a AssignedField<'a, Val>, &'a [CommentOrNewline<'a>]),
     SpaceAfter(&'a AssignedField<'a, Val>, &'a [CommentOrNewline<'a>]),
-
-    /// A malformed assigned field, which will code gen to a runtime error
-    Malformed(&'a str),
 }
 
 impl<'a, Val> AssignedField<'a, Val> {
@@ -1653,7 +1643,7 @@ impl<'a, Val> AssignedField<'a, Val> {
                 Self::RequiredValue(_, _, val)
                 | Self::OptionalValue(_, _, val)
                 | Self::IgnoredValue(_, _, val) => break Some(val),
-                Self::LabelOnly(_) | Self::Malformed(_) => break None,
+                Self::LabelOnly(_) => break None,
                 Self::SpaceBefore(next, _) | Self::SpaceAfter(next, _) => current = *next,
             }
         }
@@ -2518,7 +2508,6 @@ impl<'a> Malformed for Expr<'a> {
             ParensAround(expr) => expr.is_malformed(),
 
             MalformedIdent(_, _) |
-            MalformedClosure |
             MalformedSuffixed(..) |
             PrecedenceConflict(_) |
             EmptyRecordBuilder(_) |
@@ -2593,7 +2582,6 @@ impl<'a, T: Malformed> Malformed for AssignedField<'a, T> {
             AssignedField::SpaceBefore(field, _) | AssignedField::SpaceAfter(field, _) => {
                 field.is_malformed()
             }
-            AssignedField::Malformed(_) => true,
         }
     }
 }
@@ -2815,7 +2803,6 @@ impl<'a> Malformed for Tag<'a> {
         match self {
             Tag::Apply { name: _, args } => args.iter().any(|arg| arg.is_malformed()),
             Tag::SpaceBefore(tag, _) | Tag::SpaceAfter(tag, _) => tag.is_malformed(),
-            Tag::Malformed(_) => true,
         }
     }
 }

crates/compiler/parse/src/expr.rs

@@ -2180,7 +2180,6 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
         | Expr::DbgStmt(_, _)
         | Expr::LowLevelDbg(_, _, _)
         | Expr::Return(_, _)
-        | Expr::MalformedClosure
         | Expr::MalformedSuffixed(..)
         | Expr::PrecedenceConflict { .. }
         | Expr::EmptyRecordBuilder(_)
@@ -2254,7 +2253,6 @@ fn assigned_expr_field_to_pattern_help<'a>(
             arena.alloc(assigned_expr_field_to_pattern_help(arena, nested)?),
             spaces,
         ),
-        AssignedField::Malformed(string) => Pattern::Malformed(string),
         AssignedField::IgnoredValue(_, _, _) => return Err(()),
     })
 }

crates/compiler/parse/src/normalize.rs

@@ -556,7 +556,6 @@ impl<'a, T: Normalize<'a> + Copy + std::fmt::Debug> Normalize<'a> for AssignedFi
                 arena.alloc(c.normalize(arena)),
             ),
             AssignedField::LabelOnly(a) => AssignedField::LabelOnly(a.normalize(arena)),
-            AssignedField::Malformed(a) => AssignedField::Malformed(a),
             AssignedField::SpaceBefore(a, _) => a.normalize(arena),
             AssignedField::SpaceAfter(a, _) => a.normalize(arena),
         }
@@ -784,7 +783,6 @@ impl<'a> Normalize<'a> for Expr<'a> {
                 a.normalize(arena)
             }
             Expr::MalformedIdent(a, b) => Expr::MalformedIdent(a, remove_spaces_bad_ident(b)),
-            Expr::MalformedClosure => Expr::MalformedClosure,
             Expr::MalformedSuffixed(a) => Expr::MalformedSuffixed(a),
             Expr::PrecedenceConflict(a) => Expr::PrecedenceConflict(a),
             Expr::SpaceBefore(a, _) => a.normalize(arena),
@@ -938,7 +936,6 @@ impl<'a> Normalize<'a> for Tag<'a> {
                 name: name.normalize(arena),
                 args: args.normalize(arena),
             },
-            Tag::Malformed(a) => Tag::Malformed(a),
             Tag::SpaceBefore(a, _) => a.normalize(arena),
             Tag::SpaceAfter(a, _) => a.normalize(arena),
         }