borrowck error E0499 migrate

Author: AndyJado

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -40,51 +40,43 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
     pub(crate) fn cannot_mutably_borrow_multiply(
         &self,
         new_loan_span: Span,
-        desc: &str,
-        opt_via: &str,
+        new_place_name: &str,
+        place: &str,
         old_loan_span: Span,
-        old_opt_via: &str,
+        old_place: &str,
         old_load_end_span: Option<Span>,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        let via =
-            |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {})", msg) };
-        let mut err = struct_span_err!(
-            self,
-            new_loan_span,
-            E0499,
-            "cannot borrow {}{} as mutable more than once at a time",
-            desc,
-            via(opt_via),
-        );
-        if old_loan_span == new_loan_span {
+        use crate::session_diagnostics::MutBorrowMulti::*;
+        let via = |msg: &str| msg.is_empty();
+        self.infcx.tcx.sess.create_err(if old_loan_span == new_loan_span {
             // Both borrows are happening in the same place
             // Meaning the borrow is occurring in a loop
-            err.span_label(
+            SameSpan {
+                new_place_name,
+                place,
+                old_place,
+                is_place_empty: via(place),
                 new_loan_span,
-                format!(
-                    "{}{} was mutably borrowed here in the previous iteration of the loop{}",
-                    desc,
-                    via(opt_via),
-                    opt_via,
-                ),
-            );
-            if let Some(old_load_end_span) = old_load_end_span {
-                err.span_label(old_load_end_span, "mutable borrow ends here");
+                old_load_end_span,
+                eager_label: crate::session_diagnostics::MutMultiLoopLabel {
+                    new_place_name,
+                    place,
+                    is_place_empty: via(place),
+                    new_loan_span,
+                },
             }
         } else {
-            err.span_label(
-                old_loan_span,
-                format!("first mutable borrow occurs here{}", via(old_opt_via)),
-            );
-            err.span_label(
+            ChangedSpan {
+                new_place_name,
+                place,
+                old_place,
+                is_place_empty: via(place),
+                is_old_place_empty: via(old_place),
                 new_loan_span,
-                format!("second mutable borrow occurs here{}", via(opt_via)),
-            );
-            if let Some(old_load_end_span) = old_load_end_span {
-                err.span_label(old_load_end_span, "first borrow ends here");
+                old_loan_span,
+                old_load_end_span,
             }
-        }
-        err
+        })
     }
 
     pub(crate) fn cannot_uniquely_borrow_by_two_closures(

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1300,6 +1300,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
     /// cannot borrow `a.u` (via `a.u.z.c`) as immutable because it is also borrowed as
     /// mutable (via `a.u.s.b`) [E0502]
     /// ```
+    // FIXME: first 3 out of 4 can contain English word value, note for diagnostic migration
     pub(crate) fn describe_place_for_conflicting_borrow(
         &self,
         first_borrowed_place: Place<'tcx>,

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -707,3 +707,45 @@ pub(crate) struct UseMutBorrowErr<'a> {
     #[label(borrow_span_label)]
     pub borrow_span: Span,
 }
+
+#[derive(Diagnostic)]
+pub(crate) enum MutBorrowMulti<'a> {
+    #[diag(borrowck_cannot_mutably_borrow_multiply_same_span, code = "E0499")]
+    SameSpan {
+        new_place_name: &'a str,
+        place: &'a str,
+        old_place: &'a str,
+        is_place_empty: bool,
+        #[primary_span]
+        new_loan_span: Span,
+        #[label]
+        old_load_end_span: Option<Span>,
+        #[subdiagnostic(eager)]
+        eager_label: MutMultiLoopLabel<'a>,
+    },
+    #[diag(borrowck_cannot_mutably_borrow_multiply, code = "E0499")]
+    ChangedSpan {
+        new_place_name: &'a str,
+        place: &'a str,
+        old_place: &'a str,
+        is_place_empty: bool,
+        is_old_place_empty: bool,
+        #[primary_span]
+        #[label(second_mut_borrow_label)]
+        new_loan_span: Span,
+        #[label]
+        old_loan_span: Span,
+        #[label(first_mut_end_label)]
+        old_load_end_span: Option<Span>,
+    },
+}
+
+#[derive(Subdiagnostic)]
+#[label(borrowck_mutably_borrow_multiply_loop_label)]
+pub(crate) struct MutMultiLoopLabel<'a> {
+    pub new_place_name: &'a str,
+    pub place: &'a str,
+    pub is_place_empty: bool,
+    #[primary_span]
+    pub new_loan_span: Span,
+}

compiler/rustc_error_messages/locales/en-US/borrowck.ftl

@@ -434,3 +434,31 @@ borrowck_cannot_use_when_mutably_borrowed =
         [value] value
         *[other] {$borrow_desc}
     } occurs here
+
+borrowck_cannot_mutably_borrow_multiply_same_span =
+    cannot borrow {$new_place_name}{$is_place_empty ->
+        *[true] {""}
+        [false] {""} (via {$place})
+    } as mutable more than once at a time
+    .label = mutable borrow ends here
+
+borrowck_mutably_borrow_multiply_loop_label =
+    {$new_place_name}{$is_place_empty ->
+        *[true] {""}
+        [false] {""} (via {$place})
+    } was mutably borrowed here in the previous iteration of the loop{$place}
+
+borrowck_cannot_mutably_borrow_multiply =
+    cannot borrow {$new_place_name}{$is_place_empty ->
+        *[true] {""}
+        [false] {""} (via {$place})
+    } as mutable more than once at a time
+    .label = first mutable borrow occurs here{$is_old_place_empty ->
+        *[true] {""}
+        [false] {""} (via {$old_place})
+    }
+    .second_mut_borrow_label = second mutable borrow occurs here{$is_place_empty ->
+        *[true] {""}
+        [false] {""} (via {$place})
+    }
+    .first_mut_end_label = first borrow ends here