E0502 && should we trim end of a ftl msg as well?

Author: AndyJado

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -161,41 +161,32 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         msg_old: &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,
-            span,
-            E0502,
-            "cannot borrow {}{} as {} because {} is also borrowed as {}{}",
+        use crate::session_diagnostics::BorrowOccurLabel::*;
+        let via = |msg: &str| msg.is_empty();
+        let (new_occur, old_occur) = if msg_new == "" {
+            // If `msg_new` is empty, then this isn't a borrow of a union field.
+            (Here { span, kind: kind_new }, Here { span: old_span, kind: kind_old })
+        } else {
+            // If `msg_new` isn't empty, then this a borrow of a union field.
+            (
+                HereOverlap { span, kind_new, msg_new, msg_old },
+                HereVia { span: old_span, kind_old, is_msg_old_empty: via(msg_old), msg_old },
+            )
+        };
+        self.infcx.tcx.sess.create_err(crate::session_diagnostics::ReborrowBorrowedErr {
             desc_new,
-            via(msg_new),
+            is_msg_new_empty: via(msg_new),
+            msg_new,
             kind_new,
             noun_old,
             kind_old,
-            via(msg_old),
-        );
-
-        if msg_new == "" {
-            // If `msg_new` is empty, then this isn't a borrow of a union field.
-            err.span_label(span, format!("{} borrow occurs here", kind_new));
-            err.span_label(old_span, format!("{} borrow occurs here", kind_old));
-        } else {
-            // If `msg_new` isn't empty, then this a borrow of a union field.
-            err.span_label(
-                span,
-                format!(
-                    "{} borrow of {} -- which overlaps with {} -- occurs here",
-                    kind_new, msg_new, msg_old,
-                ),
-            );
-            err.span_label(old_span, format!("{} borrow occurs here{}", kind_old, via(msg_old)));
-        }
-
-        if let Some(old_load_end_span) = old_load_end_span {
-            err.span_label(old_load_end_span, format!("{} borrow ends here", kind_old));
-        }
-        err
+            is_msg_old_empty: via(msg_old),
+            msg_old,
+            span,
+            old_load_end_span,
+            new_occur,
+            old_occur,
+        })
     }
 
     pub(crate) fn cannot_assign_to_borrowed(

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -784,3 +784,50 @@ pub(crate) struct ClosureReBorrowErr<'a> {
     pub previous_end_span: Option<Span>,
     pub second_borrow_desc: &'a str,
 }
+
+#[derive(Subdiagnostic)]
+pub(crate) enum BorrowOccurLabel<'a> {
+    #[label(borrowck_borrow_occurs_here)]
+    Here {
+        #[primary_span]
+        span: Span,
+        kind: &'a str,
+    },
+    #[label(borrowck_borrow_occurs_here_overlap)]
+    HereOverlap {
+        #[primary_span]
+        span: Span,
+        kind_new: &'a str,
+        msg_new: &'a str,
+        msg_old: &'a str,
+    },
+    #[label(borrowck_borrow_occurs_here_via)]
+    HereVia {
+        #[primary_span]
+        span: Span,
+        kind_old: &'a str,
+        is_msg_old_empty: bool,
+        msg_old: &'a str,
+    },
+}
+
+#[derive(Diagnostic)]
+#[diag(borrowck_cannot_reborrow_already_borrowed, code = "E0502")]
+pub(crate) struct ReborrowBorrowedErr<'a> {
+    pub desc_new: &'a str,
+    pub is_msg_new_empty: bool,
+    pub msg_new: &'a str,
+    pub kind_new: &'a str,
+    pub noun_old: &'a str,
+    pub kind_old: &'a str,
+    pub is_msg_old_empty: bool,
+    pub msg_old: &'a str,
+    #[primary_span]
+    pub span: Span,
+    #[label]
+    pub old_load_end_span: Option<Span>,
+    #[subdiagnostic(eager)]
+    pub new_occur: BorrowOccurLabel<'a>,
+    #[subdiagnostic(eager)]
+    pub old_occur: BorrowOccurLabel<'a>,
+}

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

@@ -474,3 +474,24 @@ borrowck_cannot_reborrow_already_uniquely_borrowed =
     .label = {$second_borrow_desc}borrow occurs here{$opt_via}
     .occurs_label = {$container_name} construction occurs here{$old_opt_via}
     .ends_label = borrow from closure ends here
+
+borrowck_borrow_occurs_here = {$kind} borrow occurs here
+
+borrowck_borrow_occurs_here_overlap =
+    {$kind_new} borrow of {$msg_new} -- which overlaps with {$msg_old} -- occurs here
+
+borrowck_borrow_occurs_here_via =
+    {$kind_old} borrow occurs here {$is_msg_old_empty ->
+        *[true] {""}
+        [false] (via {$msg_old})
+    }
+
+borrowck_cannot_reborrow_already_borrowed =
+    cannot borrow {$desc_new}{$is_msg_new_empty ->
+        *[true] {""}
+        [false] {""} (via {$msg_new})
+    } as {$kind_new} because {$noun_old} is also borrowed as {$kind_old}{$is_msg_old_empty ->
+        *[true] {""}
+        [false] {""} (via {$msg_old})
+    }
+    .label = {$kind_old} borrow ends here