use record for PrecedenceConflict

compiler/can/src/expr.rs

@@ -720,7 +720,12 @@ pub fn canonicalize_expr<'a>(
             )
         }
 
-        ast::Expr::PrecedenceConflict(whole_region, binop1, binop2, _expr) => {
+        ast::Expr::PrecedenceConflict {
+            whole_region,
+            binop1,
+            binop2,
+            expr: _,
+        } => {
             use roc_problem::can::RuntimeError::*;
 
             let problem = PrecedenceProblem::BothNonAssociative(*whole_region, *binop1, *binop2);

compiler/can/src/operator.rs

@@ -117,8 +117,8 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Located<Expr<'a>>) -> &'a
         | Nested(MalformedIdent(_, _))
         | MalformedClosure
         | Nested(MalformedClosure)
-        | PrecedenceConflict(_, _, _, _)
+        | PrecedenceConflict { .. }
-        | Nested(PrecedenceConflict(_, _, _, _))
+        | Nested(PrecedenceConflict { .. })
         | GlobalTag(_)
         | Nested(GlobalTag(_))
         | PrivateTag(_)
@@ -517,12 +517,12 @@ fn desugar_bin_op<'a>(arena: &'a Bump, loc_expr: &'a Located<Expr<'_>>) -> &'a L
                                             },
                                         );
                                         let region = broken_expr.region;
-                                        let value = Expr::PrecedenceConflict(
+                                        let value = Expr::PrecedenceConflict {
-                                            loc_expr.region,
+                                            whole_region: loc_expr.region,
-                                            stack_op,
+                                            binop1: stack_op,
-                                            bad_op,
+                                            binop2: bad_op,
-                                            arena.alloc(broken_expr),
+                                            expr: arena.alloc(broken_expr),
-                                        );
+                                        };
 
                                         return arena.alloc(Located { region, value });
                                     }

compiler/fmt/src/expr.rs

@@ -74,9 +74,10 @@ impl<'a> Formattable<'a> for Expr<'a> {
                 next_is_multiline_bin_op || loc_left.is_multiline() || loc_right.is_multiline()
             }
 
-            UnaryOp(loc_subexpr, _) | PrecedenceConflict(_, _, _, loc_subexpr) => {
+            UnaryOp(loc_subexpr, _)
-                loc_subexpr.is_multiline()
+            | PrecedenceConflict {
-            }
+                expr: loc_subexpr, ..
+            } => loc_subexpr.is_multiline(),
 
             ParensAround(subexpr) | Nested(subexpr) => subexpr.is_multiline(),
 
@@ -316,7 +317,7 @@ impl<'a> Formattable<'a> for Expr<'a> {
             }
             MalformedIdent(_, _) => {}
             MalformedClosure => {}
-            PrecedenceConflict(_, _, _, _) => {}
+            PrecedenceConflict { .. } => {}
         }
     }
 }

compiler/parse/src/ast.rs

@@ -155,7 +155,12 @@ pub enum Expr<'a> {
     MalformedClosure,
     // Both operators were non-associative, e.g. (True == False == False).
     // We should tell the author to disambiguate by grouping them with parens.
-    PrecedenceConflict(Region, Loc<BinOp>, Loc<BinOp>, &'a Loc<Expr<'a>>),
+    PrecedenceConflict {
+        whole_region: Region,
+        binop1: Loc<BinOp>,
+        binop2: Loc<BinOp>,
+        expr: &'a Loc<Expr<'a>>,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]

compiler/parse/src/expr.rs

@@ -1389,7 +1389,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
         | Expr::If(_, _)
         | Expr::When(_, _)
         | Expr::MalformedClosure
-        | Expr::PrecedenceConflict(_, _, _, _)
+        | Expr::PrecedenceConflict { .. }
         | Expr::Record {
             update: Some(_), ..
         }

editor/src/lang/expr.rs

@@ -779,7 +779,7 @@ pub fn to_expr2<'a>(
             (expr, output)
         }
 
-        PrecedenceConflict(_whole_region, _binop1, _binop2, _expr) => {
+        PrecedenceConflict { .. } => {
             //            use roc_problem::can::RuntimeError::*;
             //
             //            let problem = PrecedenceProblem::BothNonAssociative(