nit fix

Author: AndyJado

compiler/rustc_borrowck/messages.ftl

@@ -474,12 +474,6 @@ borrowck_path_does_not_live_long_enough =
 borrowck_perhaps_save_in_new_local_to_drop =
     for example, you could save the expression's value in a new local variable `x` and then make `x` be the expression at the end of the block
 
-borrowck_require_mutable_binding =
-    calling `{$place}` requires mutable binding due to {$reason ->
-        [borrow] mutable borrow of `{$upvar}`
-        *[mutation] possible mutation of `{$upvar}`
-    }
-
 borrowck_return_fnmut =
     change this to return `FnMut` instead of `Fn`
 
@@ -536,13 +530,6 @@ borrowck_used_here_by_closure =
 borrowck_used_impl_require_static =
     the used `impl` has a `'static` requirement
 
-borrowck_used_non_generic_for_generic =
-    used non-generic {$descr ->
-    [lifetime] lifetime
-    [type] type
-    *[constant] constant
-    } `{$arg}` for generic parameter
-
 borrowck_value_capture_here =
     value captured {$is_within ->
         [true] here by coroutine

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -53,21 +53,21 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         old_load_end_span: Option<Span>,
     ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
         use crate::session_diagnostics::MutBorrowMulti::*;
-        let via = |msg: &str| msg.is_empty();
+        let via = place.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
             SameSpan {
                 new_place_name,
                 place,
                 old_place,
-                is_place_empty: via(place),
+                is_place_empty: via,
                 new_loan_span,
                 old_load_end_span,
                 eager_label: crate::session_diagnostics::MutMultiLoopLabel {
                     new_place_name,
                     place,
-                    is_place_empty: via(place),
+                    is_place_empty: via,
                     new_loan_span,
                 },
             }
@@ -76,8 +76,8 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
                 new_place_name,
                 place,
                 old_place,
-                is_place_empty: via(place),
-                is_old_place_empty: via(old_place),
+                is_place_empty: via,
+                is_old_place_empty: old_place.is_empty(),
                 new_loan_span,
                 old_loan_span,
                 old_load_end_span,

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1795,7 +1795,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
+    // FIXME(#100717): In the return value, the first three strings can contain untranslated text.
     pub(crate) fn describe_place_for_conflicting_borrow(
         &self,
         first_borrowed_place: Place<'tcx>,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -719,7 +719,6 @@ impl<'tcx> BorrowedContentSource<'tcx> {
         }
     }
 
-    // ready to remove
     pub(super) fn describe_for_immutable_place(&self, tcx: TyCtxt<'_>) -> Option<String> {
         match *self {
             BorrowedContentSource::DerefRawPointer => None,

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -61,7 +61,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 
         let mut err;
         let item_msg;
-        let diagnosing: PlaceAndReason<'_>;
+        let diagnostic: PlaceAndReason<'_>;
         let mut opt_source = None;
         let access_place_desc = self.describe_any_place(access_place.as_ref());
         debug!("report_mutability_error: access_place_desc={:?}", access_place_desc);
@@ -102,7 +102,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     return;
                 } else {
                     item_msg = access_place_desc;
-                    diagnosing = if self.is_upvar_field_projection(access_place.as_ref()).is_some()
+                    diagnostic = if self.is_upvar_field_projection(access_place.as_ref()).is_some()
                     {
                         PlaceAndReason::DeclaredImmute(item_msg.clone(), None)
                     } else {
@@ -116,7 +116,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 if self.body.local_decls[local].is_ref_for_guard() =>
             {
                 item_msg = access_place_desc;
-                diagnosing = PlaceAndReason::InPatternGuard(item_msg.clone())
+                diagnostic = PlaceAndReason::InPatternGuard(access_place_desc)
             }
             PlaceRef { local, projection: [ProjectionElem::Deref] }
                 if self.body.local_decls[local].is_ref_to_static() =>
@@ -145,7 +145,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         the_place_err.ty(self.body, self.infcx.tcx).ty
                     ));
 
-                    diagnosing = if self.is_upvar_field_projection(access_place.as_ref()).is_some()
+                    diagnostic = if self.is_upvar_field_projection(access_place.as_ref()).is_some()
                     {
                         PlaceAndReason::SelfCaptured(item_msg.clone())
                     } else {
@@ -196,14 +196,13 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         let mut mut_error = None;
         let mut count = 1;
 
-        let cant_access_here = |sp: Span| match error_access {
+        let access_diagnose_builder = |sp: Span| match error_access {
             AccessKind::MutableBorrow => FnMutBumpFn::CannotBorrowMut { sp },
             AccessKind::Mutate => FnMutBumpFn::CannotAssign { sp },
         };
         let span = match error_access {
-            // cannot assign only happen in Mutate
             AccessKind::Mutate => {
-                err = self.cannot_assign(span, diagnosing);
+                err = self.cannot_assign(span, diagnostic);
                 act = "assign";
                 acted_on = "written";
                 span
@@ -234,11 +233,11 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                             suggest = false;
                         } else {
                             err =
-                                self.cannot_borrow_path_as_mutable_because(borrow_span, diagnosing);
+                                self.cannot_borrow_path_as_mutable_because(borrow_span, diagnostic);
                         }
                     }
                     _ => {
-                        err = self.cannot_borrow_path_as_mutable_because(borrow_span, diagnosing);
+                        err = self.cannot_borrow_path_as_mutable_because(borrow_span, diagnostic);
                     }
                 }
                 if suggest {
@@ -278,7 +277,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         ProjectionElem::Deref,
                     ],
             } => {
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
 
                 let place = Place::ty_from(local, proj_base, self.body, self.infcx.tcx);
                 if let Some(span) = get_mut_span_in_struct_field(self.infcx.tcx, place.ty, *field) {
@@ -300,7 +299,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     .is_some_and(|l| mut_borrow_of_mutable_ref(l, self.local_names[local])) =>
             {
                 let decl = &self.body.local_decls[local];
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
                 if let Some(mir::Statement {
                     source_info,
                     kind:
@@ -385,7 +384,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 assert_eq!(local_decl.mutability, Mutability::Not);
 
                 if count < 10 {
-                    err.subdiagnostic(cant_access_here(span));
+                    err.subdiagnostic(access_diagnose_builder(span));
                 }
                 if suggest {
                     self.construct_mut_suggestion_for_local_binding_patterns(&mut err, local);
@@ -407,7 +406,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 
                 let captured_place = &self.upvars[upvar_index.index()].place;
 
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
 
                 let upvar_hir_id = captured_place.get_root_variable();
 
@@ -462,7 +461,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     .span_to_snippet(span)
                     .is_ok_and(|snippet| snippet.starts_with("&mut ")) =>
             {
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
                 err.span_suggestion(
                     span,
                     "try removing `&mut` here",
@@ -474,7 +473,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             PlaceRef { local, projection: [ProjectionElem::Deref] }
                 if self.body.local_decls[local].is_ref_for_guard() =>
             {
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
                 err.note(
                     "variables bound in patterns are immutable until the end of the pattern guard",
                 );
@@ -518,12 +517,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             PlaceRef { local, projection: [ProjectionElem::Deref] }
                 if local == ty::CAPTURE_STRUCT_LOCAL && !self.upvars.is_empty() =>
             {
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
                 self.expected_fn_found_fn_mut_call(&mut err);
             }
 
             PlaceRef { local: _, projection: [.., ProjectionElem::Deref] } => {
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
 
                 match opt_source {
                     Some(BorrowedContentSource::OverloadedDeref(ty)) => {
@@ -544,7 +543,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             }
 
             _ => {
-                err.subdiagnostic(cant_access_here(span));
+                err.subdiagnostic(access_diagnose_builder(span));
             }
         }
 

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -160,7 +160,7 @@ impl RegionName {
             RegionNameSource::AnonRegionFromUpvar(span, upvar_name) => {
                 diag.subdiagnostic(RegionNameLabels::LifetimeInTypeOf {
                     span: *span,
-                    upvar_name: upvar_name.to_ident_string(),
+                    upvar_name,
                     rg_name: self,
                 });
             }

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -1,7 +1,7 @@
 use rustc_errors::MultiSpan;
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::{GenericArg, Ty};
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 use crate::diagnostics::RegionName;
 
@@ -540,7 +540,7 @@ pub(crate) enum RegionNameLabels<'a> {
     LifetimeInTypeOf {
         #[primary_span]
         span: Span,
-        upvar_name: String,
+        upvar_name: &'a Symbol,
         rg_name: &'a RegionName,
     },
     #[label(borrowck_yield_type_is_type)]