place and reason as a IntodiagnosticArg type

Author: AndyJado

compiler/rustc_borrowck/messages.ftl

@@ -36,25 +36,25 @@ borrowck_assign_place_behind_ref =
     cannot assign to {$place}, which is behind a `&` reference
 
 borrowck_assign_place_declared_immute =
-    cannot assign to {$any_place}, as it is not declared as mutable
+    cannot assign to {$place}, as it is not declared as mutable
 
 borrowck_assign_place_in_fn =
-    cannot assign to {$path}, as it is a captured variable in a `Fn` closure
+    cannot assign to {$place}, as it is a captured variable in a `Fn` closure
 
 borrowck_assign_place_in_pattern_guard_immute =
-    cannot assign to {$path}, as it is immutable for the pattern guard
+    cannot assign to {$place}, as it is immutable for the pattern guard
 
 borrowck_assign_place_static =
-    cannot assign to immutable static item {$path}
+    cannot assign to immutable static item {$place}
 
 borrowck_assign_symbol_declared_immute =
-    cannot assign to {$any_place}, as `{$name}` is not declared as mutable
+    cannot assign to {$place}, as `{$name}` is not declared as mutable
 
 borrowck_assign_symbol_static =
-    cannot assign to {$path}, as `{$static_name}` is an immutable static item
+    cannot assign to {$place}, as `{$static_name}` is an immutable static item
 
 borrowck_assign_upvar_in_fn =
-    cannot assign to {$path}, as `Fn` closures cannot mutate their captured variables
+    cannot assign to {$place}, as `Fn` closures cannot mutate their captured variables
 
 borrowck_borrow_due_to_use_closure =
     borrow occurs due to use in closure
@@ -396,13 +396,13 @@ borrowck_mut_borrow_data_behind_ref =
     cannot borrow data in a `&` reference as mutable
 
 borrowck_mut_borrow_place_declared_immute =
-    cannot borrow {$any_place} as mutable, as it is not declared as mutable
+    cannot borrow {$place} as mutable, as it is not declared as mutable
 
 borrowck_mut_borrow_place_in_pattern_guard_immute =
-    cannot borrow {$path} as mutable, as it is immutable for the pattern guard
+    cannot borrow {$place} as mutable, as it is immutable for the pattern guard
 
 borrowck_mut_borrow_place_static =
-    cannot borrow immutable static item {$path} as mutable
+    cannot borrow immutable static item {$place} as mutable
 
 borrowck_mut_borrow_self_behind_const_pointer =
     cannot borrow {$place} as mutable, as it is behind a `*const` pointer
@@ -417,16 +417,16 @@ borrowck_mut_borrow_self_behind_ref =
     cannot borrow {$place} as mutable, as it is behind a `&` reference
 
 borrowck_mut_borrow_self_in_fn =
-    cannot borrow {$path} as mutable, as it is a captured variable in a `Fn` closure
+    cannot borrow {$place} as mutable, as it is a captured variable in a `Fn` closure
 
 borrowck_mut_borrow_symbol_declared_immute =
-    cannot borrow {$any_place} as mutable, as `{$name}` is not declared as mutable
+    cannot borrow {$place} as mutable, as `{$name}` is not declared as mutable
 
 borrowck_mut_borrow_symbol_static =
-    cannot borrow {$path} as mutable, as `{$static_name}` is an immutable static item
+    cannot borrow {$place} as mutable, as `{$static_name}` is an immutable static item
 
 borrowck_mut_borrow_upvar_in_fn =
-    cannot borrow {$path} as mutable, as `Fn` closures cannot mutate their captured variables
+    cannot borrow {$place} as mutable, as `Fn` closures cannot mutate their captured variables
 
 borrowck_mutably_borrow_multiply_loop_label =
     {$is_place_empty ->

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -226,25 +226,23 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         let diag = match path_and_reason {
             PlaceAndReason::DeclaredImmute(place, name) => {
                 if let Some(name) = name {
-                    AssignErr::SymbolDeclaredImmute { span, any_place: place, name }
+                    AssignErr::SymbolDeclaredImmute { span, place, name }
                 } else {
-                    AssignErr::PlaceDeclaredImmute { span, any_place: place }
+                    AssignErr::PlaceDeclaredImmute { span, place }
                 }
             }
-            PlaceAndReason::InPatternGuard(place) => {
-                AssignErr::PatternGuardImmute { span, path: place }
-            }
+            PlaceAndReason::InPatternGuard(place) => AssignErr::PatternGuardImmute { span, place },
             PlaceAndReason::StaticItem(place, name) => {
                 if let Some(name) = name {
-                    AssignErr::SymbolStatic { span, path: place, static_name: name }
+                    AssignErr::SymbolStatic { span, place, static_name: name }
                 } else {
-                    AssignErr::PlaceStatic { span, path: place }
+                    AssignErr::PlaceStatic { span, place }
                 }
             }
-            PlaceAndReason::UpvarCaptured(place) => AssignErr::UpvarInFn { span, path: place },
-            PlaceAndReason::SelfCaptured(place) => AssignErr::CapturedInFn { span, path: place },
+            PlaceAndReason::UpvarCaptured(place) => AssignErr::UpvarInFn { span, place },
+            PlaceAndReason::SelfCaptured(place) => AssignErr::CapturedInFn { span, place },
             PlaceAndReason::BehindPointer(place, pointer_ty, name) => {
-                if let Some(place) = place {
+                if place.0.is_some() {
                     match pointer_ty {
                         crate::diagnostics::BorrowedContentSource::DerefRawPointer => {
                             AssignErr::PlaceBehindRawPointer { span, place }
@@ -364,25 +362,25 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
         let diag = match path_and_reason {
             PlaceAndReason::DeclaredImmute(place, name) => {
                 if let Some(name) = name {
-                    MutBorrowErr::SymbolDeclaredImmute { span, any_place: place, name }
+                    MutBorrowErr::SymbolDeclaredImmute { span, place, name }
                 } else {
-                    MutBorrowErr::PlaceDeclaredImmute { span, any_place: place }
+                    MutBorrowErr::PlaceDeclaredImmute { span, place }
                 }
             }
             PlaceAndReason::InPatternGuard(place) => {
-                MutBorrowErr::PatternGuardImmute { span, path: place }
+                MutBorrowErr::PatternGuardImmute { span, place }
             }
             PlaceAndReason::StaticItem(place, name) => {
                 if let Some(name) = name {
-                    MutBorrowErr::SymbolStatic { span, path: place, static_name: name }
+                    MutBorrowErr::SymbolStatic { span, place, static_name: name }
                 } else {
-                    MutBorrowErr::PlaceStatic { span, path: place }
+                    MutBorrowErr::PlaceStatic { span, place }
                 }
             }
-            PlaceAndReason::UpvarCaptured(place) => MutBorrowErr::UpvarInFn { span, path: place },
-            PlaceAndReason::SelfCaptured(place) => MutBorrowErr::CapturedInFn { span, path: place },
+            PlaceAndReason::UpvarCaptured(place) => MutBorrowErr::UpvarInFn { span, place },
+            PlaceAndReason::SelfCaptured(place) => MutBorrowErr::CapturedInFn { span, place },
             PlaceAndReason::BehindPointer(place, pointer_ty, name) => {
-                if let Some(place) = place {
+                if place.0.is_some() {
                     match pointer_ty {
                         crate::diagnostics::BorrowedContentSource::DerefRawPointer => {
                             MutBorrowErr::SelfBehindRawPointer { span, place }

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -5,7 +5,7 @@ use crate::session_diagnostics::{
     CaptureVarKind, CaptureVarPathUseCause, OnClosureNote,
 };
 use itertools::Itertools;
-use rustc_errors::{Applicability, Diagnostic};
+use rustc_errors::{Applicability, Diagnostic, DiagnosticArgValue, IntoDiagnosticArg};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::CoroutineKind;
@@ -63,6 +63,25 @@ pub(super) struct DescribePlaceOpt {
 
 pub(super) struct IncludingTupleField(pub(super) bool);
 
+#[derive(Debug)]
+pub(super) struct DescribedPlace(pub(super) Option<String>);
+
+impl IntoDiagnosticArg for DescribedPlace {
+    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
+        let mut desc = self.0;
+        desc.as_mut().map(|s| {
+            s.reserve(2);
+            s.insert(0, '`');
+            s.push('`');
+            s
+        });
+        match desc {
+            Some(descr) => descr.into_diagnostic_arg(),
+            None => "value".into_diagnostic_arg(),
+        }
+    }
+}
+
 impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
     /// Adds a suggestion when a closure is invoked twice with a moved variable or when a closure
     /// is moved after being invoked.
@@ -174,6 +193,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         }
     }
 
+    pub(super) fn describe_place_typed(&self, place_ref: PlaceRef<'tcx>) -> DescribedPlace {
+        DescribedPlace(self.describe_place(place_ref))
+    }
+
     /// End-user visible description of `place` if one can be found.
     /// If the place is a temporary for instance, `None` will be returned.
     pub(super) fn describe_place(&self, place_ref: PlaceRef<'tcx>) -> Option<String> {
@@ -631,7 +654,7 @@ impl UseSpans<'_> {
     ) {
         if let UseSpans::ClosureUse { coroutine_kind, capture_kind_span, path_span, .. } = self {
             if capture_kind_span != path_span {
-                err.subdiagnostic(match kind {
+                let diag = match kind {
                     Some(kd) => match kd {
                         rustc_middle::mir::BorrowKind::Shared
                         | rustc_middle::mir::BorrowKind::Shallow => {
@@ -643,7 +666,12 @@ impl UseSpans<'_> {
                         }
                     },
                     None => CaptureVarKind::Move { kind_span: capture_kind_span },
-                });
+                };
+
+                match handler {
+                    Some(hd) => err.eager_subdiagnostic(hd, diag),
+                    None => err.subdiagnostic(diag),
+                };
             };
             let diag = f(coroutine_kind, path_span);
             match handler {

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -21,6 +21,8 @@ use crate::session_diagnostics::{BorrowMutUpvarLable, FnMutBumpFn, OnModifyTy};
 use crate::util::FindAssignments;
 use crate::MirBorrowckCtxt;
 
+use super::DescribedPlace;
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub(crate) enum AccessKind {
     MutableBorrow,
@@ -30,17 +32,17 @@ pub(crate) enum AccessKind {
 #[derive(Debug)]
 pub(crate) enum PlaceAndReason<'a> {
     // place, name
-    DeclaredImmute(String, Option<String>),
+    DeclaredImmute(DescribedPlace, Option<String>),
     // place
-    InPatternGuard(String),
+    InPatternGuard(DescribedPlace),
     // place, name
-    StaticItem(String, Option<String>),
+    StaticItem(DescribedPlace, Option<String>),
     // place
-    UpvarCaptured(String),
+    UpvarCaptured(DescribedPlace),
     // place
-    SelfCaptured(String),
+    SelfCaptured(DescribedPlace),
     // place, pointer_type, name
-    BehindPointer(Option<String>, BorrowedContentSource<'a>, Option<String>),
+    BehindPointer(DescribedPlace, BorrowedContentSource<'a>, Option<String>),
 }
 
 impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
@@ -60,20 +62,20 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         );
 
         let mut err;
-        let item_msg;
         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);
+        let access_place_desc = self.describe_place_typed(access_place.as_ref());
+
+        let access_place_desc_dbg = self.describe_any_place(access_place.as_ref());
+        debug!("report_mutability_error: access_place_desc={:?}", access_place_desc_dbg);
 
         match the_place_err {
             PlaceRef { local, projection: [] } => {
-                item_msg = access_place_desc;
-                diagnosing = if access_place.as_local().is_some() {
-                    PlaceAndReason::DeclaredImmute(item_msg.clone(), None)
+                diagnostic = if access_place.as_local().is_some() {
+                    PlaceAndReason::DeclaredImmute(access_place_desc, None)
                 } else {
                     let name = self.local_names[local].expect("immutable unnamed local");
-                    PlaceAndReason::DeclaredImmute(item_msg.clone(), Some(name.to_string()))
+                    PlaceAndReason::DeclaredImmute(access_place_desc, Some(name.to_string()))
                 };
             }
 
@@ -101,34 +103,31 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     // If we deref an immutable ref then the suggestion here doesn't help.
                     return;
                 } else {
-                    item_msg = access_place_desc;
                     diagnostic = if self.is_upvar_field_projection(access_place.as_ref()).is_some()
                     {
-                        PlaceAndReason::DeclaredImmute(item_msg.clone(), None)
+                        PlaceAndReason::DeclaredImmute(access_place_desc, None)
                     } else {
                         let name = self.upvars[upvar_index.index()].place.to_string(self.infcx.tcx);
-                        PlaceAndReason::DeclaredImmute(item_msg.clone(), Some(name))
+                        PlaceAndReason::DeclaredImmute(access_place_desc, Some(name))
                     }
                 }
             }
 
             PlaceRef { local, projection: [ProjectionElem::Deref] }
                 if self.body.local_decls[local].is_ref_for_guard() =>
             {
-                item_msg = access_place_desc;
                 diagnostic = PlaceAndReason::InPatternGuard(access_place_desc)
             }
             PlaceRef { local, projection: [ProjectionElem::Deref] }
                 if self.body.local_decls[local].is_ref_to_static() =>
             {
-                diagnosing = if access_place.projection.len() == 1 {
-                    PlaceAndReason::StaticItem(access_place_desc.clone(), None)
+                diagnostic = if access_place.projection.len() == 1 {
+                    PlaceAndReason::StaticItem(access_place_desc, None)
                 } else {
-                    item_msg = access_place_desc;
                     let local_info = self.body.local_decls[local].local_info();
                     if let LocalInfo::StaticRef { def_id, .. } = *local_info {
                         let static_name = &self.infcx.tcx.item_name(def_id);
-                        PlaceAndReason::StaticItem(item_msg.clone(), Some(static_name.to_string()))
+                        PlaceAndReason::StaticItem(access_place_desc, Some(static_name.to_string()))
                     } else {
                         bug!("is_ref_to_static return true, but not ref to static?");
                     }
@@ -139,32 +138,29 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                     && proj_base.is_empty()
                     && !self.upvars.is_empty()
                 {
-                    item_msg = access_place_desc;
                     debug_assert!(self.body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty.is_ref());
                     debug_assert!(is_closure_or_coroutine(
                         the_place_err.ty(self.body, self.infcx.tcx).ty
                     ));
 
                     diagnostic = if self.is_upvar_field_projection(access_place.as_ref()).is_some()
                     {
-                        PlaceAndReason::SelfCaptured(item_msg.clone())
+                        PlaceAndReason::SelfCaptured(access_place_desc)
                     } else {
-                        PlaceAndReason::UpvarCaptured(item_msg.clone())
+                        PlaceAndReason::UpvarCaptured(access_place_desc)
                     }
                 } else {
-                    let source = self.borrowed_content_source(PlaceRef {
+                    let ptr_source = self.borrowed_content_source(PlaceRef {
                         local: the_place_err.local,
                         projection: proj_base,
                     });
-                    let diag_msg = source.describe_for_immutable_place(self.infcx.tcx);
-                    diagnosing = if let Some(desc) = self.describe_place(access_place.as_ref()) {
-                        item_msg = format!("`{desc}`");
-                        PlaceAndReason::BehindPointer(Some(item_msg.clone()), source, diag_msg)
-                    } else {
-                        PlaceAndReason::BehindPointer(None, source, diag_msg)
-                    };
-
-                    opt_source = Some(source);
+                    let name = ptr_source.describe_for_immutable_place(self.infcx.tcx);
+                    diagnostic = PlaceAndReason::BehindPointer(
+                        self.describe_place_typed(access_place.as_ref()),
+                        ptr_source,
+                        name,
+                    );
+                    opt_source = Some(ptr_source);
                 }
             }
 
@@ -184,8 +180,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         }
 
         debug!(
-            "report_mutability_error: item_msg and reason is moved to a struct due to diagnosing migration: {:?}",
-            &diagnosing
+            "report_mutability_error: item_msg and reason is moved to a struct due to diagnosing migration: [E0594] & [E0596], now they are typed value: {:?}",
+            &diagnostic
         );
 
         // `act` and `acted_on` are strings that let us abstract over