borrowck some amount of diag migration

Author: AndyJado

compiler/rustc_borrowck/src/borrow_set.rs

@@ -1,3 +1,5 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 use crate::nll::ToRegionVid;
 use crate::path_utils::allow_two_phase_borrow;
 use crate::place_ext::PlaceExt;

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -4,13 +4,19 @@ use rustc_errors::{
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::Span;
 
+use crate::session_diagnostics::{
+    AssignBorrowErr, BorrowAcrossDestructor, BorrowAcrossGeneratorYield, ClosureConstructLabel,
+    InteriorDropMoveErr, MoveBorrowedErr, PathShortLive, TwoClosuresUniquelyBorrowErr,
+    UseMutBorrowErr,
+};
+
 impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
     pub(crate) fn cannot_move_when_borrowed(
         &self,
         span: Span,
         desc: &str,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        struct_span_err!(self, span, E0505, "cannot move out of {} because it is borrowed", desc,)
+        self.infcx.tcx.sess.create_err(MoveBorrowedErr { desc, span })
     }
 
     pub(crate) fn cannot_use_when_mutably_borrowed(
@@ -20,17 +26,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         borrow_span: Span,
         borrow_desc: &str,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        let mut err = struct_span_err!(
-            self,
-            span,
-            E0503,
-            "cannot use {} because it was mutably borrowed",
-            desc,
-        );
-
-        err.span_label(borrow_span, format!("borrow of {} occurs here", borrow_desc));
-        err.span_label(span, format!("use of borrowed {}", borrow_desc));
-        err
+        self.infcx.tcx.sess.create_err(UseMutBorrowErr { desc, borrow_desc, span, borrow_span })
     }
 
     pub(crate) fn cannot_mutably_borrow_multiply(
@@ -90,26 +86,22 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         old_loan_span: Span,
         old_load_end_span: Option<Span>,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        let mut err = struct_span_err!(
-            self,
-            new_loan_span,
-            E0524,
-            "two closures require unique access to {} at the same time",
-            desc,
-        );
+        let case: ClosureConstructLabel;
+        let diff_span: Option<Span>;
         if old_loan_span == new_loan_span {
-            err.span_label(
-                old_loan_span,
-                "closures are constructed here in different iterations of loop",
-            );
+            case = ClosureConstructLabel::Both { old_loan_span };
+            diff_span = None;
         } else {
-            err.span_label(old_loan_span, "first closure is constructed here");
-            err.span_label(new_loan_span, "second closure is constructed here");
+            case = ClosureConstructLabel::First { old_loan_span };
+            diff_span = Some(new_loan_span);
         }
-        if let Some(old_load_end_span) = old_load_end_span {
-            err.span_label(old_load_end_span, "borrow from first closure ends here");
-        }
-        err
+        self.infcx.tcx.sess.create_err(TwoClosuresUniquelyBorrowErr {
+            desc,
+            case,
+            new_loan_span,
+            old_load_end_span,
+            diff_span,
+        })
     }
 
     pub(crate) fn cannot_uniquely_borrow_by_one_closure(
@@ -233,17 +225,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         borrow_span: Span,
         desc: &str,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        let mut err = struct_span_err!(
-            self,
-            span,
-            E0506,
-            "cannot assign to {} because it is borrowed",
-            desc,
-        );
-
-        err.span_label(borrow_span, format!("borrow of {} occurs here", desc));
-        err.span_label(span, format!("assignment to borrowed {} occurs here", desc));
-        err
+        self.infcx.tcx.sess.create_err(AssignBorrowErr { desc, span, borrow_span })
     }
 
     pub(crate) fn cannot_reassign_immutable(
@@ -303,15 +285,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         move_from_span: Span,
         container_ty: Ty<'_>,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        let mut err = struct_span_err!(
-            self,
-            move_from_span,
-            E0509,
-            "cannot move out of type `{}`, which implements the `Drop` trait",
-            container_ty,
-        );
-        err.span_label(move_from_span, "cannot move out of here");
-        err
+        self.infcx.tcx.sess.create_err(InteriorDropMoveErr { container_ty, move_from_span })
     }
 
     pub(crate) fn cannot_act_on_moved_value(
@@ -370,34 +344,22 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         span: Span,
         yield_span: Span,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        let mut err = struct_span_err!(
-            self,
-            span,
-            E0626,
-            "borrow may still be in use when generator yields",
-        );
-        err.span_label(yield_span, "possible yield occurs here");
-        err
+        self.infcx.tcx.sess.create_err(BorrowAcrossGeneratorYield { span, yield_span })
     }
 
     pub(crate) fn cannot_borrow_across_destructor(
         &self,
         borrow_span: Span,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        struct_span_err!(
-            self,
-            borrow_span,
-            E0713,
-            "borrow may still be in use when destructor runs",
-        )
+        self.infcx.tcx.sess.create_err(BorrowAcrossDestructor { borrow_span })
     }
 
     pub(crate) fn path_does_not_live_long_enough(
         &self,
         span: Span,
         path: &str,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
-        struct_span_err!(self, span, E0597, "{} does not live long enough", path,)
+        self.infcx.tcx.sess.create_err(PathShortLive { path, span })
     }
 
     pub(crate) fn cannot_return_reference_to_local(

compiler/rustc_borrowck/src/constraint_generation.rs

@@ -1,3 +1,5 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 use rustc_infer::infer::InferCtxt;
 use rustc_middle::mir::visit::TyContext;
 use rustc_middle::mir::visit::Visitor;

compiler/rustc_borrowck/src/constraints/graph.rs

@@ -1,3 +1,6 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
+
 use rustc_data_structures::graph;
 use rustc_index::vec::IndexVec;
 use rustc_middle::mir::ConstraintCategory;

compiler/rustc_borrowck/src/constraints/mod.rs

@@ -1,3 +1,6 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
+
 use rustc_data_structures::graph::scc::Sccs;
 use rustc_index::vec::IndexVec;
 use rustc_middle::mir::ConstraintCategory;

compiler/rustc_borrowck/src/consumers.rs

@@ -1,3 +1,5 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 //! This file provides API for compiler consumers.
 
 use rustc_hir::def_id::LocalDefId;

compiler/rustc_borrowck/src/dataflow.rs

@@ -1,3 +1,5 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 use rustc_data_structures::fx::FxHashMap;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::{self, BasicBlock, Body, Location, Place};

compiler/rustc_borrowck/src/def_use.rs

@@ -1,3 +1,5 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 use rustc_middle::mir::visit::{
     MutatingUseContext, NonMutatingUseContext, NonUseContext, PlaceContext,
 };

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -1,3 +1,6 @@
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
+
 use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed};
 use rustc_infer::infer::canonical::Canonical;
 use rustc_infer::infer::error_reporting::nice_region_error::NiceRegionError;

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -180,10 +180,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 let move_spans = self.move_spans(moved_place.as_ref(), move_out.source);
                 let move_span = move_spans.args_or_use();
 
-                let move_msg = if move_spans.for_closure() { " into closure" } else { "" };
+                let move_msg = if move_spans.for_closure() { "InClosure" } else { "" };
 
                 let loop_message = if location == move_out.source || move_site.traversed_back_edge {
-                    ", in previous iteration of loop"
+                    "InLoop"
                 } else {
                     ""
                 };