good old stash

Author: AndyJado

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -4,6 +4,11 @@ use rustc_errors::{
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::Span;
 
+use crate::session_diagnostics::{
+    AssignBorrowErr, BorrowAcrossDestructor, BorrowAcrossGeneratorYield, InteriorDropMoveErr,
+    PathShortLive, UseMutBorrowErr,
+};
+
 impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
     pub(crate) fn cannot_move_when_borrowed(
         &self,
@@ -29,17 +34,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(
@@ -99,26 +94,19 @@ 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,
-        );
-        if old_loan_span == new_loan_span {
-            err.span_label(
-                old_loan_span,
-                "closures are constructed here in different iterations of loop",
-            );
+        use crate::session_diagnostics::ClosureConstructLabel::*;
+        let (case, diff_span) = if old_loan_span == new_loan_span {
+            (Both { old_loan_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");
-        }
-        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
+            (First { old_loan_span }, Some(new_loan_span))
+        };
+        self.infcx.tcx.sess.create_err(crate::session_diagnostics::TwoClosuresUniquelyBorrowErr {
+            desc,
+            case,
+            new_loan_span,
+            old_load_end_span,
+            diff_span,
+        })
     }
 
     pub(crate) fn cannot_uniquely_borrow_by_one_closure(
@@ -242,17 +230,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(
@@ -312,15 +290,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(
@@ -379,34 +349,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/diagnostics/move_errors.rs

@@ -8,6 +8,7 @@ use rustc_span::Span;
 
 use crate::diagnostics::{DescribePlaceOpt, UseSpans};
 use crate::prefixes::PrefixSet;
+use crate::session_diagnostics::AddMoveErr;
 use crate::MirBorrowckCtxt;
 
 // Often when desugaring a pattern match we may have many individual moves in
@@ -512,9 +513,9 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             let binding_span = bind_to.source_info.span;
 
             if j == 0 {
-                err.span_label(binding_span, "data moved here");
+                err.subdiagnostic(AddMoveErr::Here { binding_span });
             } else {
-                err.span_label(binding_span, "...and here");
+                err.subdiagnostic(AddMoveErr::AndHere { binding_span });
             }
 
             if binds_to.len() == 1 {
@@ -529,10 +530,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         }
 
         if binds_to.len() > 1 {
-            err.note(
-                "move occurs because these variables have types that \
-                      don't implement the `Copy` trait",
-            );
+            err.subdiagnostic(AddMoveErr::MovedNotCopy);
         }
     }
 }

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1,3 +1,6 @@
+// #![deny(rustc::untranslatable_diagnostic)]
+// #![deny(rustc::diagnostic_outside_of_impl)]
+
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir as hir;
 use rustc_hir::intravisit::Visitor;
@@ -14,6 +17,7 @@ use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{sym, BytePos, Span};
 
 use crate::diagnostics::BorrowedContentSource;
+use crate::session_diagnostics::FnMutBumpFn;
 use crate::MirBorrowckCtxt;
 use rustc_const_eval::util::collect_writes::FindAssignments;
 
@@ -964,7 +968,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 
     /// Targeted error when encountering an `FnMut` closure where an `Fn` closure was expected.
     fn expected_fn_found_fn_mut_call(&self, err: &mut Diagnostic, sp: Span, act: &str) {
-        err.span_label(sp, format!("cannot {act}"));
+        err.subdiagnostic(FnMutBumpFn::Cannot { act, sp });
 
         let hir = self.infcx.tcx.hir();
         let closure_id = self.mir_hir_id();
@@ -1018,9 +1022,9 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     _ => None,
                 };
                 if let Some(span) = arg {
-                    err.span_label(span, "change this to accept `FnMut` instead of `Fn`");
-                    err.span_label(func.span, "expects `Fn` instead of `FnMut`");
-                    err.span_label(closure_span, "in this closure");
+                    err.subdiagnostic(FnMutBumpFn::AcceptFnMut { span });
+                    err.subdiagnostic(FnMutBumpFn::AcceptFn { span: func.span });
+                    err.subdiagnostic(FnMutBumpFn::Here { span: closure_span });
                     look_at_return = false;
                 }
             }
@@ -1041,12 +1045,9 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     kind: hir::ImplItemKind::Fn(sig, _),
                     ..
                 }) => {
-                    err.span_label(ident.span, "");
-                    err.span_label(
-                        sig.decl.output.span(),
-                        "change this to return `FnMut` instead of `Fn`",
-                    );
-                    err.span_label(closure_span, "in this closure");
+                    err.subdiagnostic(FnMutBumpFn::EmptyLabel { span: ident.span });
+                    err.subdiagnostic(FnMutBumpFn::ReturnFnMut { span: sig.decl.output.span() });
+                    err.subdiagnostic(FnMutBumpFn::Here { span: closure_span });
                 }
                 _ => {}
             }

compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs

@@ -171,9 +171,7 @@ impl OutlivesSuggestionBuilder {
         if let (Some(fr_name), Some(outlived_fr_name)) = (fr_name, outlived_fr_name)
             && !matches!(outlived_fr_name.source, RegionNameSource::Static)
         {
-            diag.help(&format!(
-                "consider adding the following bound: `{fr_name}: {outlived_fr_name}`",
-            ));
+            diag.subdiagnostic(crate::session_diagnostics::OnLifetimeBound::Add { fr_name: &fr_name, outlived_fr_name: &outlived_fr_name });
         }
     }
 

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -710,7 +710,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             },
             _ => LifetimeReturnCategoryErr::ShortReturn {
                 span: *span,
-                category_desc: category.description(),
+                category: category.description(),
                 free_region_name: &fr_name,
                 outlived_fr_name,
             },

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -10,6 +10,7 @@ use rustc_middle::ty::{self, DefIdTree, RegionVid, Ty};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
 
+use crate::session_diagnostics::RegionNameLabels;
 use crate::{nll::ToRegionVid, universal_regions::DefiningTy, MirBorrowckCtxt};
 
 /// A name for a particular region used in emitting diagnostics. This name could be a generated
@@ -133,16 +134,17 @@ impl RegionName {
                 RegionNameHighlight::MatchedAdtAndSegment(span),
                 _,
             ) => {
-                diag.span_label(*span, format!("let's call this `{self}`"));
+                diag.subdiagnostic(RegionNameLabels::NameRegion { span: *span, rg_name: self });
             }
             RegionNameSource::AnonRegionFromArgument(RegionNameHighlight::Occluded(
                 span,
                 type_name,
             )) => {
-                diag.span_label(
-                    *span,
-                    format!("lifetime `{self}` appears in the type {type_name}"),
-                );
+                diag.subdiagnostic(RegionNameLabels::LifetimeInType {
+                    span: *span,
+                    type_name: &type_name,
+                    rg_name: self,
+                });
             }
             RegionNameSource::AnonRegionFromOutput(
                 RegionNameHighlight::Occluded(span, type_name),
@@ -156,10 +158,11 @@ impl RegionName {
                 );
             }
             RegionNameSource::AnonRegionFromUpvar(span, upvar_name) => {
-                diag.span_label(
-                    *span,
-                    format!("lifetime `{self}` appears in the type of `{upvar_name}`"),
-                );
+                diag.subdiagnostic(RegionNameLabels::LifetimeInTypeOf {
+                    span: *span,
+                    upvar_name: upvar_name.to_ident_string(),
+                    rg_name: self,
+                });
             }
             RegionNameSource::AnonRegionFromOutput(
                 RegionNameHighlight::CannotMatchHirTy(span, type_name),
@@ -168,13 +171,17 @@ impl RegionName {
                 diag.span_label(*span, format!("return type{mir_description} is {type_name}"));
             }
             RegionNameSource::AnonRegionFromYieldTy(span, type_name) => {
-                diag.span_label(*span, format!("yield type is {type_name}"));
+                diag.subdiagnostic(RegionNameLabels::YieldTypeIsTpye {
+                    span: *span,
+                    type_name: &type_name,
+                });
             }
             RegionNameSource::AnonRegionFromImplSignature(span, location) => {
-                diag.span_label(
-                    *span,
-                    format!("lifetime `{self}` appears in the `impl`'s {location}"),
-                );
+                diag.subdiagnostic(RegionNameLabels::LifetimeInImpl {
+                    span: *span,
+                    rg_name: self,
+                    location: &location,
+                });
             }
             RegionNameSource::Static => {}
         }

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -12,6 +12,8 @@ use rustc_span::Span;
 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
 use rustc_trait_selection::traits::ObligationCtxt;
 
+use crate::session_diagnostics::{OpaqueTyDefineErrCause, OpaqueTypeNotDefine};
+
 use super::RegionInferenceContext;
 
 impl<'tcx> RegionInferenceContext<'tcx> {
@@ -367,15 +369,12 @@ fn check_opaque_type_parameter_valid(
         let arg_is_param = match arg.unpack() {
             GenericArgKind::Type(ty) => matches!(ty.kind(), ty::Param(_)),
             GenericArgKind::Lifetime(lt) if lt.is_static() => {
-                tcx.sess
-                    .struct_span_err(span, "non-defining opaque type use in defining scope")
-                    .span_label(
-                        tcx.def_span(opaque_generics.param_at(i, tcx).def_id),
-                        "cannot use static lifetime; use a bound lifetime \
-                                    instead or remove the lifetime parameter from the \
-                                    opaque type",
-                    )
-                    .emit();
+                tcx.sess.emit_err(OpaqueTypeNotDefine {
+                    cause: OpaqueTyDefineErrCause::UsedStaticLifetime {
+                        span: tcx.def_span(opaque_generics.param_at(i, tcx).def_id),
+                    },
+                    span,
+                });
                 return false;
             }
             GenericArgKind::Lifetime(lt) => {
@@ -389,17 +388,14 @@ fn check_opaque_type_parameter_valid(
         } else {
             // Prevent `fn foo() -> Foo<u32>` from being defining.
             let opaque_param = opaque_generics.param_at(i, tcx);
-            tcx.sess
-                .struct_span_err(span, "non-defining opaque type use in defining scope")
-                .span_note(
-                    tcx.def_span(opaque_param.def_id),
-                    &format!(
-                        "used non-generic {} `{}` for generic parameter",
-                        opaque_param.kind.descr(),
-                        arg,
-                    ),
-                )
-                .emit();
+            tcx.sess.emit_err(OpaqueTypeNotDefine {
+                cause: OpaqueTyDefineErrCause::NonGenericUsed {
+                    span: tcx.def_span(opaque_param.def_id),
+                    descr: &opaque_param.kind.descr(),
+                    arg: arg.to_string(),
+                },
+                span,
+            });
             return false;
         }
     }