compiler/rustc_borrowck/src/diagnostics/mod.rs

   1 //! Borrow checker diagnostics.
   2
   3 use itertools::Itertools;
   4 use rustc_const_eval::util::{call_kind, CallDesugaringKind};
   5 use rustc_errors::{Applicability, Diagnostic};
   6 use rustc_hir as hir;
   7 use rustc_hir::def::{CtorKind, Namespace};
   8 use rustc_hir::GeneratorKind;
   9 use rustc_infer::infer::{LateBoundRegionConversionTime, TyCtxtInferExt};
  10 use rustc_middle::mir::tcx::PlaceTy;
  11 use rustc_middle::mir::{
  12     AggregateKind, Constant, FakeReadCause, Field, Local, LocalInfo, LocalKind, Location, Operand,
  13     Place, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator, TerminatorKind,
  14 };
  15 use rustc_middle::ty::print::Print;
  16 use rustc_middle::ty::{self, DefIdTree, Instance, Ty, TyCtxt};
  17 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult};
  18 use rustc_span::def_id::LocalDefId;
  19 use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
  20 use rustc_target::abi::VariantIdx;
  21 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
  22 use rustc_trait_selection::traits::{
  23     type_known_to_meet_bound_modulo_regions, Obligation, ObligationCause,
  24 };
  25
  26 use super::borrow_set::BorrowData;
  27 use super::MirBorrowckCtxt;
  28
  29 mod find_all_local_uses;
  30 mod find_use;
  31 mod outlives_suggestion;
  32 mod region_name;
  33 mod var_name;
  34
  35 mod bound_region_errors;
  36 mod conflict_errors;
  37 mod explain_borrow;
  38 mod move_errors;
  39 mod mutability_errors;
  40 mod region_errors;
  41
  42 pub(crate) use bound_region_errors::{ToUniverseInfo, UniverseInfo};
  43 pub(crate) use mutability_errors::AccessKind;
  44 pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder;
  45 pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
  46 pub(crate) use region_name::{RegionName, RegionNameSource};
  47 pub(crate) use rustc_const_eval::util::CallKind;
  48
  49 pub(super) struct DescribePlaceOpt {
  50     pub including_downcast: bool,
  51
  52     /// Enable/Disable tuple fields.
  53     /// For example `x` tuple. if it's `true` `x.0`. Otherwise `x`
  54     pub including_tuple_field: bool,
  55 }
  56
  57 pub(super) struct IncludingTupleField(pub(super) bool);
  58
  59 impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  60     /// Adds a suggestion when a closure is invoked twice with a moved variable or when a closure
  61     /// is moved after being invoked.
  62     ///
  63     /// ```text
  64     /// note: closure cannot be invoked more than once because it moves the variable `dict` out of
  65     ///       its environment
  66     ///   --> $DIR/issue-42065.rs:16:29
  67     ///    |
  68     /// LL |         for (key, value) in dict {
  69     ///    |                             ^^^^
  70     /// ```
  71     pub(super) fn add_moved_or_invoked_closure_note(
  72         &self,
  73         location: Location,
  74         place: PlaceRef<'tcx>,
  75         diag: &mut Diagnostic,
  76     ) -> bool {
  77         debug!("add_moved_or_invoked_closure_note: location={:?} place={:?}", location, place);
  78         let mut target = place.local_or_deref_local();
  79         for stmt in &self.body[location.block].statements[location.statement_index..] {
  80             debug!("add_moved_or_invoked_closure_note: stmt={:?} target={:?}", stmt, target);
  81             if let StatementKind::Assign(box (into, Rvalue::Use(from))) = &stmt.kind {
  82                 debug!("add_fnonce_closure_note: into={:?} from={:?}", into, from);
  83                 match from {
  84                     Operand::Copy(place) | Operand::Move(place)
  85                         if target == place.local_or_deref_local() =>
  86                     {
  87                         target = into.local_or_deref_local()
  88                     }
  89                     _ => {}
  90                 }
  91             }
  92         }
  93
  94         // Check if we are attempting to call a closure after it has been invoked.
  95         let terminator = self.body[location.block].terminator();
  96         debug!("add_moved_or_invoked_closure_note: terminator={:?}", terminator);
  97         if let TerminatorKind::Call {
  98             func: Operand::Constant(box Constant { literal, .. }),
  99             args,
 100             ..
 101         } = &terminator.kind
 102         {
 103             if let ty::FnDef(id, _) = *literal.ty().kind() {
 104                 debug!("add_moved_or_invoked_closure_note: id={:?}", id);
 105                 if Some(self.infcx.tcx.parent(id)) == self.infcx.tcx.lang_items().fn_once_trait() {
 106                     let closure = match args.first() {
 107                         Some(Operand::Copy(place) | Operand::Move(place))
 108                             if target == place.local_or_deref_local() =>
 109                         {
 110                             place.local_or_deref_local().unwrap()
 111                         }
 112                         _ => return false,
 113                     };
 114
 115                     debug!("add_moved_or_invoked_closure_note: closure={:?}", closure);
 116                     if let ty::Closure(did, _) = self.body.local_decls[closure].ty.kind() {
 117                         let did = did.expect_local();
 118                         let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(did);
 119
 120                         if let Some((span, hir_place)) =
 121                             self.infcx.tcx.typeck(did).closure_kind_origins().get(hir_id)
 122                         {
 123                             diag.span_note(
 124                                 *span,
 125                                 &format!(
 126                                     "closure cannot be invoked more than once because it moves the \
 127                                     variable `{}` out of its environment",
 128                                     ty::place_to_string_for_capture(self.infcx.tcx, hir_place)
 129                                 ),
 130                             );
 131                             return true;
 132                         }
 133                     }
 134                 }
 135             }
 136         }
 137
 138         // Check if we are just moving a closure after it has been invoked.
 139         if let Some(target) = target {
 140             if let ty::Closure(did, _) = self.body.local_decls[target].ty.kind() {
 141                 let did = did.expect_local();
 142                 let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(did);
 143
 144                 if let Some((span, hir_place)) =
 145                     self.infcx.tcx.typeck(did).closure_kind_origins().get(hir_id)
 146                 {
 147                     diag.span_note(
 148                         *span,
 149                         &format!(
 150                             "closure cannot be moved more than once as it is not `Copy` due to \
 151                              moving the variable `{}` out of its environment",
 152                             ty::place_to_string_for_capture(self.infcx.tcx, hir_place)
 153                         ),
 154                     );
 155                     return true;
 156                 }
 157             }
 158         }
 159         false
 160     }
 161
 162     /// End-user visible description of `place` if one can be found.
 163     /// If the place is a temporary for instance, `"value"` will be returned.
 164     pub(super) fn describe_any_place(&self, place_ref: PlaceRef<'tcx>) -> String {
 165         match self.describe_place(place_ref) {
 166             Some(mut descr) => {
 167                 // Surround descr with `backticks`.
 168                 descr.reserve(2);
 169                 descr.insert(0, '`');
 170                 descr.push('`');
 171                 descr
 172             }
 173             None => "value".to_string(),
 174         }
 175     }
 176
 177     /// End-user visible description of `place` if one can be found.
 178     /// If the place is a temporary for instance, `None` will be returned.
 179     pub(super) fn describe_place(&self, place_ref: PlaceRef<'tcx>) -> Option<String> {
 180         self.describe_place_with_options(
 181             place_ref,
 182             DescribePlaceOpt { including_downcast: false, including_tuple_field: true },
 183         )
 184     }
 185
 186     /// End-user visible description of `place` if one can be found. If the place is a temporary
 187     /// for instance, `None` will be returned.
 188     /// `IncludingDowncast` parameter makes the function return `None` if `ProjectionElem` is
 189     /// `Downcast` and `IncludingDowncast` is true
 190     pub(super) fn describe_place_with_options(
 191         &self,
 192         place: PlaceRef<'tcx>,
 193         opt: DescribePlaceOpt,
 194     ) -> Option<String> {
 195         let local = place.local;
 196         let mut autoderef_index = None;
 197         let mut buf = String::new();
 198         let mut ok = self.append_local_to_string(local, &mut buf);
 199
 200         for (index, elem) in place.projection.into_iter().enumerate() {
 201             match elem {
 202                 ProjectionElem::Deref => {
 203                     if index == 0 {
 204                         if self.body.local_decls[local].is_ref_for_guard() {
 205                             continue;
 206                         }
 207                         if let Some(box LocalInfo::StaticRef { def_id, .. }) =
 208                             &self.body.local_decls[local].local_info
 209                         {
 210                             buf.push_str(self.infcx.tcx.item_name(*def_id).as_str());
 211                             ok = Ok(());
 212                             continue;
 213                         }
 214                     }
 215                     if let Some(field) = self.is_upvar_field_projection(PlaceRef {
 216                         local,
 217                         projection: place.projection.split_at(index + 1).0,
 218                     }) {
 219                         let var_index = field.index();
 220                         buf = self.upvars[var_index].place.to_string(self.infcx.tcx);
 221                         ok = Ok(());
 222                         if !self.upvars[var_index].by_ref {
 223                             buf.insert(0, '*');
 224                         }
 225                     } else {
 226                         if autoderef_index.is_none() {
 227                             autoderef_index =
 228                                 match place.projection.into_iter().rev().find_position(|elem| {
 229                                     !matches!(
 230                                         elem,
 231                                         ProjectionElem::Deref | ProjectionElem::Downcast(..)
 232                                     )
 233                                 }) {
 234                                     Some((index, _)) => Some(place.projection.len() - index),
 235                                     None => Some(0),
 236                                 };
 237                         }
 238                         if index >= autoderef_index.unwrap() {
 239                             buf.insert(0, '*');
 240                         }
 241                     }
 242                 }
 243                 ProjectionElem::Downcast(..) if opt.including_downcast => return None,
 244                 ProjectionElem::Downcast(..) => (),
 245                 ProjectionElem::OpaqueCast(..) => (),
 246                 ProjectionElem::Field(field, _ty) => {
 247                     // FIXME(project-rfc_2229#36): print capture precisely here.
 248                     if let Some(field) = self.is_upvar_field_projection(PlaceRef {
 249                         local,
 250                         projection: place.projection.split_at(index + 1).0,
 251                     }) {
 252                         buf = self.upvars[field.index()].place.to_string(self.infcx.tcx);
 253                         ok = Ok(());
 254                     } else {
 255                         let field_name = self.describe_field(
 256                             PlaceRef { local, projection: place.projection.split_at(index).0 },
 257                             *field,
 258                             IncludingTupleField(opt.including_tuple_field),
 259                         );
 260                         if let Some(field_name_str) = field_name {
 261                             buf.push('.');
 262                             buf.push_str(&field_name_str);
 263                         }
 264                     }
 265                 }
 266                 ProjectionElem::Index(index) => {
 267                     buf.push('[');
 268                     if self.append_local_to_string(*index, &mut buf).is_err() {
 269                         buf.push('_');
 270                     }
 271                     buf.push(']');
 272                 }
 273                 ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. } => {
 274                     // Since it isn't possible to borrow an element on a particular index and
 275                     // then use another while the borrow is held, don't output indices details
 276                     // to avoid confusing the end-user
 277                     buf.push_str("[..]");
 278                 }
 279             }
 280         }
 281         ok.ok().map(|_| buf)
 282     }
 283
 284     fn describe_name(&self, place: PlaceRef<'tcx>) -> Option<Symbol> {
 285         for elem in place.projection.into_iter() {
 286             match elem {
 287                 ProjectionElem::Downcast(Some(name), _) => {
 288                     return Some(*name);
 289                 }
 290                 _ => {}
 291             }
 292         }
 293         None
 294     }
 295
 296     /// Appends end-user visible description of the `local` place to `buf`. If `local` doesn't have
 297     /// a name, or its name was generated by the compiler, then `Err` is returned
 298     fn append_local_to_string(&self, local: Local, buf: &mut String) -> Result<(), ()> {
 299         let decl = &self.body.local_decls[local];
 300         match self.local_names[local] {
 301             Some(name) if !decl.from_compiler_desugaring() => {
 302                 buf.push_str(name.as_str());
 303                 Ok(())
 304             }
 305             _ => Err(()),
 306         }
 307     }
 308
 309     /// End-user visible description of the `field`nth field of `base`
 310     fn describe_field(
 311         &self,
 312         place: PlaceRef<'tcx>,
 313         field: Field,
 314         including_tuple_field: IncludingTupleField,
 315     ) -> Option<String> {
 316         let place_ty = match place {
 317             PlaceRef { local, projection: [] } => PlaceTy::from_ty(self.body.local_decls[local].ty),
 318             PlaceRef { local, projection: [proj_base @ .., elem] } => match elem {
 319                 ProjectionElem::Deref
 320                 | ProjectionElem::Index(..)
 321                 | ProjectionElem::ConstantIndex { .. }
 322                 | ProjectionElem::Subslice { .. } => {
 323                     PlaceRef { local, projection: proj_base }.ty(self.body, self.infcx.tcx)
 324                 }
 325                 ProjectionElem::Downcast(..) => place.ty(self.body, self.infcx.tcx),
 326                 ProjectionElem::OpaqueCast(ty) => PlaceTy::from_ty(*ty),
 327                 ProjectionElem::Field(_, field_type) => PlaceTy::from_ty(*field_type),
 328             },
 329         };
 330         self.describe_field_from_ty(
 331             place_ty.ty,
 332             field,
 333             place_ty.variant_index,
 334             including_tuple_field,
 335         )
 336     }
 337
 338     /// End-user visible description of the `field_index`nth field of `ty`
 339     fn describe_field_from_ty(
 340         &self,
 341         ty: Ty<'_>,
 342         field: Field,
 343         variant_index: Option<VariantIdx>,
 344         including_tuple_field: IncludingTupleField,
 345     ) -> Option<String> {
 346         if ty.is_box() {
 347             // If the type is a box, the field is described from the boxed type
 348             self.describe_field_from_ty(ty.boxed_ty(), field, variant_index, including_tuple_field)
 349         } else {
 350             match *ty.kind() {
 351                 ty::Adt(def, _) => {
 352                     let variant = if let Some(idx) = variant_index {
 353                         assert!(def.is_enum());
 354                         &def.variant(idx)
 355                     } else {
 356                         def.non_enum_variant()
 357                     };
 358                     if !including_tuple_field.0 && variant.ctor_kind() == Some(CtorKind::Fn) {
 359                         return None;
 360                     }
 361                     Some(variant.fields[field.index()].name.to_string())
 362                 }
 363                 ty::Tuple(_) => Some(field.index().to_string()),
 364                 ty::Ref(_, ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) => {
 365                     self.describe_field_from_ty(ty, field, variant_index, including_tuple_field)
 366                 }
 367                 ty::Array(ty, _) | ty::Slice(ty) => {
 368                     self.describe_field_from_ty(ty, field, variant_index, including_tuple_field)
 369                 }
 370                 ty::Closure(def_id, _) | ty::Generator(def_id, _, _) => {
 371                     // We won't be borrowck'ing here if the closure came from another crate,
 372                     // so it's safe to call `expect_local`.
 373                     //
 374                     // We know the field exists so it's safe to call operator[] and `unwrap` here.
 375                     let def_id = def_id.expect_local();
 376                     let var_id = self
 377                         .infcx
 378                         .tcx
 379                         .typeck(def_id)
 380                         .closure_min_captures_flattened(def_id)
 381                         .nth(field.index())
 382                         .unwrap()
 383                         .get_root_variable();
 384
 385                     Some(self.infcx.tcx.hir().name(var_id).to_string())
 386                 }
 387                 _ => {
 388                     // Might need a revision when the fields in trait RFC is implemented
 389                     // (https://github.com/rust-lang/rfcs/pull/1546)
 390                     bug!("End-user description not implemented for field access on `{:?}`", ty);
 391                 }
 392             }
 393         }
 394     }
 395
 396     /// Add a note that a type does not implement `Copy`
 397     pub(super) fn note_type_does_not_implement_copy(
 398         &self,
 399         err: &mut Diagnostic,
 400         place_desc: &str,
 401         ty: Ty<'tcx>,
 402         span: Option<Span>,
 403         move_prefix: &str,
 404     ) {
 405         let message = format!(
 406             "{move_prefix}move occurs because {place_desc} has type `{ty}`, which does not implement the `Copy` trait",
 407         );
 408         if let Some(span) = span {
 409             err.span_label(span, message);
 410         } else {
 411             err.note(&message);
 412         }
 413     }
 414
 415     pub(super) fn borrowed_content_source(
 416         &self,
 417         deref_base: PlaceRef<'tcx>,
 418     ) -> BorrowedContentSource<'tcx> {
 419         let tcx = self.infcx.tcx;
 420
 421         // Look up the provided place and work out the move path index for it,
 422         // we'll use this to check whether it was originally from an overloaded
 423         // operator.
 424         match self.move_data.rev_lookup.find(deref_base) {
 425             LookupResult::Exact(mpi) | LookupResult::Parent(Some(mpi)) => {
 426                 debug!("borrowed_content_source: mpi={:?}", mpi);
 427
 428                 for i in &self.move_data.init_path_map[mpi] {
 429                     let init = &self.move_data.inits[*i];
 430                     debug!("borrowed_content_source: init={:?}", init);
 431                     // We're only interested in statements that initialized a value, not the
 432                     // initializations from arguments.
 433                     let InitLocation::Statement(loc) = init.location else { continue };
 434
 435                     let bbd = &self.body[loc.block];
 436                     let is_terminator = bbd.statements.len() == loc.statement_index;
 437                     debug!(
 438                         "borrowed_content_source: loc={:?} is_terminator={:?}",
 439                         loc, is_terminator,
 440                     );
 441                     if !is_terminator {
 442                         continue;
 443                     } else if let Some(Terminator {
 444                         kind: TerminatorKind::Call { func, from_hir_call: false, .. },
 445                         ..
 446                     }) = &bbd.terminator
 447                     {
 448                         if let Some(source) =
 449                             BorrowedContentSource::from_call(func.ty(self.body, tcx), tcx)
 450                         {
 451                             return source;
 452                         }
 453                     }
 454                 }
 455             }
 456             // Base is a `static` so won't be from an overloaded operator
 457             _ => (),
 458         };
 459
 460         // If we didn't find an overloaded deref or index, then assume it's a
 461         // built in deref and check the type of the base.
 462         let base_ty = deref_base.ty(self.body, tcx).ty;
 463         if base_ty.is_unsafe_ptr() {
 464             BorrowedContentSource::DerefRawPointer
 465         } else if base_ty.is_mutable_ptr() {
 466             BorrowedContentSource::DerefMutableRef
 467         } else {
 468             BorrowedContentSource::DerefSharedRef
 469         }
 470     }
 471
 472     /// Return the name of the provided `Ty` (that must be a reference) with a synthesized lifetime
 473     /// name where required.
 474     pub(super) fn get_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String {
 475         let mut printer = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
 476
 477         // We need to add synthesized lifetimes where appropriate. We do
 478         // this by hooking into the pretty printer and telling it to label the
 479         // lifetimes without names with the value `'0`.
 480         if let ty::Ref(region, ..) = ty.kind() {
 481             match **region {
 482                 ty::ReLateBound(_, ty::BoundRegion { kind: br, .. })
 483                 | ty::RePlaceholder(ty::PlaceholderRegion { name: br, .. }) => {
 484                     printer.region_highlight_mode.highlighting_bound_region(br, counter)
 485                 }
 486                 _ => {}
 487             }
 488         }
 489
 490         ty.print(printer).unwrap().into_buffer()
 491     }
 492
 493     /// Returns the name of the provided `Ty` (that must be a reference)'s region with a
 494     /// synthesized lifetime name where required.
 495     pub(super) fn get_region_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String {
 496         let mut printer = ty::print::FmtPrinter::new(self.infcx.tcx, Namespace::TypeNS);
 497
 498         let region = if let ty::Ref(region, ..) = ty.kind() {
 499             match **region {
 500                 ty::ReLateBound(_, ty::BoundRegion { kind: br, .. })
 501                 | ty::RePlaceholder(ty::PlaceholderRegion { name: br, .. }) => {
 502                     printer.region_highlight_mode.highlighting_bound_region(br, counter)
 503                 }
 504                 _ => {}
 505             }
 506             region
 507         } else {
 508             bug!("ty for annotation of borrow region is not a reference");
 509         };
 510
 511         region.print(printer).unwrap().into_buffer()
 512     }
 513 }
 514
 515 /// The span(s) associated to a use of a place.
 516 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 517 pub(super) enum UseSpans<'tcx> {
 518     /// The access is caused by capturing a variable for a closure.
 519     ClosureUse {
 520         /// This is true if the captured variable was from a generator.
 521         generator_kind: Option<GeneratorKind>,
 522         /// The span of the args of the closure, including the `move` keyword if
 523         /// it's present.
 524         args_span: Span,
 525         /// The span of the use resulting in capture kind
 526         /// Check `ty::CaptureInfo` for more details
 527         capture_kind_span: Span,
 528         /// The span of the use resulting in the captured path
 529         /// Check `ty::CaptureInfo` for more details
 530         path_span: Span,
 531     },
 532     /// The access is caused by using a variable as the receiver of a method
 533     /// that takes 'self'
 534     FnSelfUse {
 535         /// The span of the variable being moved
 536         var_span: Span,
 537         /// The span of the method call on the variable
 538         fn_call_span: Span,
 539         /// The definition span of the method being called
 540         fn_span: Span,
 541         kind: CallKind<'tcx>,
 542     },
 543     /// This access is caused by a `match` or `if let` pattern.
 544     PatUse(Span),
 545     /// This access has a single span associated to it: common case.
 546     OtherUse(Span),
 547 }
 548
 549 impl UseSpans<'_> {
 550     pub(super) fn args_or_use(self) -> Span {
 551         match self {
 552             UseSpans::ClosureUse { args_span: span, .. }
 553             | UseSpans::PatUse(span)
 554             | UseSpans::OtherUse(span) => span,
 555             UseSpans::FnSelfUse { fn_call_span, kind: CallKind::DerefCoercion { .. }, .. } => {
 556                 fn_call_span
 557             }
 558             UseSpans::FnSelfUse { var_span, .. } => var_span,
 559         }
 560     }
 561
 562     /// Returns the span of `self`, in the case of a `ClosureUse` returns the `path_span`
 563     pub(super) fn var_or_use_path_span(self) -> Span {
 564         match self {
 565             UseSpans::ClosureUse { path_span: span, .. }
 566             | UseSpans::PatUse(span)
 567             | UseSpans::OtherUse(span) => span,
 568             UseSpans::FnSelfUse { fn_call_span, kind: CallKind::DerefCoercion { .. }, .. } => {
 569                 fn_call_span
 570             }
 571             UseSpans::FnSelfUse { var_span, .. } => var_span,
 572         }
 573     }
 574
 575     /// Returns the span of `self`, in the case of a `ClosureUse` returns the `capture_kind_span`
 576     pub(super) fn var_or_use(self) -> Span {
 577         match self {
 578             UseSpans::ClosureUse { capture_kind_span: span, .. }
 579             | UseSpans::PatUse(span)
 580             | UseSpans::OtherUse(span) => span,
 581             UseSpans::FnSelfUse { fn_call_span, kind: CallKind::DerefCoercion { .. }, .. } => {
 582                 fn_call_span
 583             }
 584             UseSpans::FnSelfUse { var_span, .. } => var_span,
 585         }
 586     }
 587
 588     pub(super) fn generator_kind(self) -> Option<GeneratorKind> {
 589         match self {
 590             UseSpans::ClosureUse { generator_kind, .. } => generator_kind,
 591             _ => None,
 592         }
 593     }
 594
 595     /// Add a span label to the arguments of the closure, if it exists.
 596     pub(super) fn args_span_label(self, err: &mut Diagnostic, message: impl Into<String>) {
 597         if let UseSpans::ClosureUse { args_span, .. } = self {
 598             err.span_label(args_span, message);
 599         }
 600     }
 601
 602     /// Add a span label to the use of the captured variable, if it exists.
 603     /// only adds label to the `path_span`
 604     pub(super) fn var_path_only_subdiag(
 605         self,
 606         err: &mut Diagnostic,
 607         action: crate::InitializationRequiringAction,
 608     ) {
 609         use crate::session_diagnostics::CaptureVarPathUseCause::*;
 610         use crate::InitializationRequiringAction::*;
 611         if let UseSpans::ClosureUse { generator_kind, path_span, .. } = self {
 612             match generator_kind {
 613                 Some(_) => {
 614                     err.subdiagnostic(match action {
 615                         Borrow => BorrowInGenerator { path_span },
 616                         MatchOn | Use => UseInGenerator { path_span },
 617                         Assignment => AssignInGenerator { path_span },
 618                         PartialAssignment => AssignPartInGenerator { path_span },
 619                     });
 620                 }
 621                 None => {
 622                     err.subdiagnostic(match action {
 623                         Borrow => BorrowInClosure { path_span },
 624                         MatchOn | Use => UseInClosure { path_span },
 625                         Assignment => AssignInClosure { path_span },
 626                         PartialAssignment => AssignPartInClosure { path_span },
 627                     });
 628                 }
 629             }
 630         }
 631     }
 632
 633     /// Add a span label to the use of the captured variable, if it exists.
 634     pub(super) fn var_span_label(
 635         self,
 636         err: &mut Diagnostic,
 637         message: impl Into<String>,
 638         kind_desc: impl Into<String>,
 639     ) {
 640         if let UseSpans::ClosureUse { capture_kind_span, path_span, .. } = self {
 641             if capture_kind_span == path_span {
 642                 err.span_label(capture_kind_span, message);
 643             } else {
 644                 let capture_kind_label =
 645                     format!("capture is {} because of use here", kind_desc.into());
 646                 let path_label = message;
 647                 err.span_label(capture_kind_span, capture_kind_label);
 648                 err.span_label(path_span, path_label);
 649             }
 650         }
 651     }
 652
 653     /// Add a subdiagnostic to the use of the captured variable, if it exists.
 654     pub(super) fn var_subdiag(
 655         self,
 656         err: &mut Diagnostic,
 657         kind: Option<rustc_middle::mir::BorrowKind>,
 658         f: impl Fn(Option<GeneratorKind>, Span) -> crate::session_diagnostics::CaptureVarCause,
 659     ) {
 660         use crate::session_diagnostics::CaptureVarKind::*;
 661         if let UseSpans::ClosureUse { generator_kind, capture_kind_span, path_span, .. } = self {
 662             if capture_kind_span != path_span {
 663                 err.subdiagnostic(match kind {
 664                     Some(kd) => match kd {
 665                         rustc_middle::mir::BorrowKind::Shared
 666                         | rustc_middle::mir::BorrowKind::Shallow
 667                         | rustc_middle::mir::BorrowKind::Unique => {
 668                             Immute { kind_span: capture_kind_span }
 669                         }
 670
 671                         rustc_middle::mir::BorrowKind::Mut { .. } => {
 672                             Mut { kind_span: capture_kind_span }
 673                         }
 674                     },
 675                     None => Move { kind_span: capture_kind_span },
 676                 });
 677             };
 678             err.subdiagnostic(f(generator_kind, path_span));
 679         }
 680     }
 681
 682     /// Returns `false` if this place is not used in a closure.
 683     pub(super) fn for_closure(&self) -> bool {
 684         match *self {
 685             UseSpans::ClosureUse { generator_kind, .. } => generator_kind.is_none(),
 686             _ => false,
 687         }
 688     }
 689
 690     /// Returns `false` if this place is not used in a generator.
 691     pub(super) fn for_generator(&self) -> bool {
 692         match *self {
 693             UseSpans::ClosureUse { generator_kind, .. } => generator_kind.is_some(),
 694             _ => false,
 695         }
 696     }
 697
 698     /// Describe the span associated with a use of a place.
 699     pub(super) fn describe(&self) -> &str {
 700         match *self {
 701             UseSpans::ClosureUse { generator_kind, .. } => {
 702                 if generator_kind.is_some() {
 703                     " in generator"
 704                 } else {
 705                     " in closure"
 706                 }
 707             }
 708             _ => "",
 709         }
 710     }
 711
 712     pub(super) fn or_else<F>(self, if_other: F) -> Self
 713     where
 714         F: FnOnce() -> Self,
 715     {
 716         match self {
 717             closure @ UseSpans::ClosureUse { .. } => closure,
 718             UseSpans::PatUse(_) | UseSpans::OtherUse(_) => if_other(),
 719             fn_self @ UseSpans::FnSelfUse { .. } => fn_self,
 720         }
 721     }
 722 }
 723
 724 pub(super) enum BorrowedContentSource<'tcx> {
 725     DerefRawPointer,
 726     DerefMutableRef,
 727     DerefSharedRef,
 728     OverloadedDeref(Ty<'tcx>),
 729     OverloadedIndex(Ty<'tcx>),
 730 }
 731
 732 impl<'tcx> BorrowedContentSource<'tcx> {
 733     pub(super) fn describe_for_unnamed_place(&self, tcx: TyCtxt<'_>) -> String {
 734         match *self {
 735             BorrowedContentSource::DerefRawPointer => "a raw pointer".to_string(),
 736             BorrowedContentSource::DerefSharedRef => "a shared reference".to_string(),
 737             BorrowedContentSource::DerefMutableRef => "a mutable reference".to_string(),
 738             BorrowedContentSource::OverloadedDeref(ty) => ty
 739                 .ty_adt_def()
 740                 .and_then(|adt| match tcx.get_diagnostic_name(adt.did())? {
 741                     name @ (sym::Rc | sym::Arc) => Some(format!("an `{name}`")),
 742                     _ => None,
 743                 })
 744                 .unwrap_or_else(|| format!("dereference of `{ty}`")),
 745             BorrowedContentSource::OverloadedIndex(ty) => format!("index of `{ty}`"),
 746         }
 747     }
 748
 749     pub(super) fn describe_for_named_place(&self) -> Option<&'static str> {
 750         match *self {
 751             BorrowedContentSource::DerefRawPointer => Some("raw pointer"),
 752             BorrowedContentSource::DerefSharedRef => Some("shared reference"),
 753             BorrowedContentSource::DerefMutableRef => Some("mutable reference"),
 754             // Overloaded deref and index operators should be evaluated into a
 755             // temporary. So we don't need a description here.
 756             BorrowedContentSource::OverloadedDeref(_)
 757             | BorrowedContentSource::OverloadedIndex(_) => None,
 758         }
 759     }
 760
 761     pub(super) fn describe_for_immutable_place(&self, tcx: TyCtxt<'_>) -> String {
 762         match *self {
 763             BorrowedContentSource::DerefRawPointer => "a `*const` pointer".to_string(),
 764             BorrowedContentSource::DerefSharedRef => "a `&` reference".to_string(),
 765             BorrowedContentSource::DerefMutableRef => {
 766                 bug!("describe_for_immutable_place: DerefMutableRef isn't immutable")
 767             }
 768             BorrowedContentSource::OverloadedDeref(ty) => ty
 769                 .ty_adt_def()
 770                 .and_then(|adt| match tcx.get_diagnostic_name(adt.did())? {
 771                     name @ (sym::Rc | sym::Arc) => Some(format!("an `{name}`")),
 772                     _ => None,
 773                 })
 774                 .unwrap_or_else(|| format!("dereference of `{ty}`")),
 775             BorrowedContentSource::OverloadedIndex(ty) => format!("an index of `{ty}`"),
 776         }
 777     }
 778
 779     fn from_call(func: Ty<'tcx>, tcx: TyCtxt<'tcx>) -> Option<Self> {
 780         match *func.kind() {
 781             ty::FnDef(def_id, substs) => {
 782                 let trait_id = tcx.trait_of_item(def_id)?;
 783
 784                 let lang_items = tcx.lang_items();
 785                 if Some(trait_id) == lang_items.deref_trait()
 786                     || Some(trait_id) == lang_items.deref_mut_trait()
 787                 {
 788                     Some(BorrowedContentSource::OverloadedDeref(substs.type_at(0)))
 789                 } else if Some(trait_id) == lang_items.index_trait()
 790                     || Some(trait_id) == lang_items.index_mut_trait()
 791                 {
 792                     Some(BorrowedContentSource::OverloadedIndex(substs.type_at(0)))
 793                 } else {
 794                     None
 795                 }
 796             }
 797             _ => None,
 798         }
 799     }
 800 }
 801
 802 impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 803     /// Finds the spans associated to a move or copy of move_place at location.
 804     pub(super) fn move_spans(
 805         &self,
 806         moved_place: PlaceRef<'tcx>, // Could also be an upvar.
 807         location: Location,
 808     ) -> UseSpans<'tcx> {
 809         use self::UseSpans::*;
 810
 811         let Some(stmt) = self.body[location.block].statements.get(location.statement_index) else {
 812             return OtherUse(self.body.source_info(location).span);
 813         };
 814
 815         debug!("move_spans: moved_place={:?} location={:?} stmt={:?}", moved_place, location, stmt);
 816         if let StatementKind::Assign(box (_, Rvalue::Aggregate(kind, places))) = &stmt.kind
 817             && let AggregateKind::Closure(def_id, _) | AggregateKind::Generator(def_id, _, _) = **kind
 818         {
 819             debug!("move_spans: def_id={:?} places={:?}", def_id, places);
 820             if let Some((args_span, generator_kind, capture_kind_span, path_span)) =
 821                 self.closure_span(def_id, moved_place, places)
 822             {
 823                 return ClosureUse {
 824                     generator_kind,
 825                     args_span,
 826                     capture_kind_span,
 827                     path_span,
 828                 };
 829             }
 830         }
 831
 832         // StatementKind::FakeRead only contains a def_id if they are introduced as a result
 833         // of pattern matching within a closure.
 834         if let StatementKind::FakeRead(box (cause, place)) = stmt.kind {
 835             match cause {
 836                 FakeReadCause::ForMatchedPlace(Some(closure_def_id))
 837                 | FakeReadCause::ForLet(Some(closure_def_id)) => {
 838                     debug!("move_spans: def_id={:?} place={:?}", closure_def_id, place);
 839                     let places = &[Operand::Move(place)];
 840                     if let Some((args_span, generator_kind, capture_kind_span, path_span)) =
 841                         self.closure_span(closure_def_id, moved_place, places)
 842                     {
 843                         return ClosureUse {
 844                             generator_kind,
 845                             args_span,
 846                             capture_kind_span,
 847                             path_span,
 848                         };
 849                     }
 850                 }
 851                 _ => {}
 852             }
 853         }
 854
 855         let normal_ret =
 856             if moved_place.projection.iter().any(|p| matches!(p, ProjectionElem::Downcast(..))) {
 857                 PatUse(stmt.source_info.span)
 858             } else {
 859                 OtherUse(stmt.source_info.span)
 860             };
 861
 862         // We are trying to find MIR of the form:
 863         // ```
 864         // _temp = _moved_val;
 865         // ...
 866         // FnSelfCall(_temp, ...)
 867         // ```
 868         //
 869         // where `_moved_val` is the place we generated the move error for,
 870         // `_temp` is some other local, and `FnSelfCall` is a function
 871         // that has a `self` parameter.
 872
 873         let target_temp = match stmt.kind {
 874             StatementKind::Assign(box (temp, _)) if temp.as_local().is_some() => {
 875                 temp.as_local().unwrap()
 876             }
 877             _ => return normal_ret,
 878         };
 879
 880         debug!("move_spans: target_temp = {:?}", target_temp);
 881
 882         if let Some(Terminator {
 883             kind: TerminatorKind::Call { fn_span, from_hir_call, .. }, ..
 884         }) = &self.body[location.block].terminator
 885         {
 886             let Some((method_did, method_substs)) =
 887                 rustc_const_eval::util::find_self_call(
 888                     self.infcx.tcx,
 889                     &self.body,
 890                     target_temp,
 891                     location.block,
 892                 )
 893             else {
 894                 return normal_ret;
 895             };
 896
 897             let kind = call_kind(
 898                 self.infcx.tcx,
 899                 self.param_env,
 900                 method_did,
 901                 method_substs,
 902                 *fn_span,
 903                 *from_hir_call,
 904                 Some(self.infcx.tcx.fn_arg_names(method_did)[0]),
 905             );
 906
 907             return FnSelfUse {
 908                 var_span: stmt.source_info.span,
 909                 fn_call_span: *fn_span,
 910                 fn_span: self.infcx.tcx.def_span(method_did),
 911                 kind,
 912             };
 913         }
 914         normal_ret
 915     }
 916
 917     /// Finds the span of arguments of a closure (within `maybe_closure_span`)
 918     /// and its usage of the local assigned at `location`.
 919     /// This is done by searching in statements succeeding `location`
 920     /// and originating from `maybe_closure_span`.
 921     pub(super) fn borrow_spans(&self, use_span: Span, location: Location) -> UseSpans<'tcx> {
 922         use self::UseSpans::*;
 923         debug!("borrow_spans: use_span={:?} location={:?}", use_span, location);
 924
 925         let target = match self.body[location.block].statements.get(location.statement_index) {
 926             Some(Statement { kind: StatementKind::Assign(box (place, _)), .. }) => {
 927                 if let Some(local) = place.as_local() {
 928                     local
 929                 } else {
 930                     return OtherUse(use_span);
 931                 }
 932             }
 933             _ => return OtherUse(use_span),
 934         };
 935
 936         if self.body.local_kind(target) != LocalKind::Temp {
 937             // operands are always temporaries.
 938             return OtherUse(use_span);
 939         }
 940
 941         for stmt in &self.body[location.block].statements[location.statement_index + 1..] {
 942             if let StatementKind::Assign(box (_, Rvalue::Aggregate(kind, places))) = &stmt.kind {
 943                 let (&def_id, is_generator) = match kind {
 944                     box AggregateKind::Closure(def_id, _) => (def_id, false),
 945                     box AggregateKind::Generator(def_id, _, _) => (def_id, true),
 946                     _ => continue,
 947                 };
 948
 949                 debug!(
 950                     "borrow_spans: def_id={:?} is_generator={:?} places={:?}",
 951                     def_id, is_generator, places
 952                 );
 953                 if let Some((args_span, generator_kind, capture_kind_span, path_span)) =
 954                     self.closure_span(def_id, Place::from(target).as_ref(), places)
 955                 {
 956                     return ClosureUse { generator_kind, args_span, capture_kind_span, path_span };
 957                 } else {
 958                     return OtherUse(use_span);
 959                 }
 960             }
 961
 962             if use_span != stmt.source_info.span {
 963                 break;
 964             }
 965         }
 966
 967         OtherUse(use_span)
 968     }
 969
 970     /// Finds the spans of a captured place within a closure or generator.
 971     /// The first span is the location of the use resulting in the capture kind of the capture
 972     /// The second span is the location the use resulting in the captured path of the capture
 973     fn closure_span(
 974         &self,
 975         def_id: LocalDefId,
 976         target_place: PlaceRef<'tcx>,
 977         places: &[Operand<'tcx>],
 978     ) -> Option<(Span, Option<GeneratorKind>, Span, Span)> {
 979         debug!(
 980             "closure_span: def_id={:?} target_place={:?} places={:?}",
 981             def_id, target_place, places
 982         );
 983         let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(def_id);
 984         let expr = &self.infcx.tcx.hir().expect_expr(hir_id).kind;
 985         debug!("closure_span: hir_id={:?} expr={:?}", hir_id, expr);
 986         if let hir::ExprKind::Closure(&hir::Closure { body, fn_decl_span, .. }) = expr {
 987             for (captured_place, place) in
 988                 self.infcx.tcx.typeck(def_id).closure_min_captures_flattened(def_id).zip(places)
 989             {
 990                 match place {
 991                     Operand::Copy(place) | Operand::Move(place)
 992                         if target_place == place.as_ref() =>
 993                     {
 994                         debug!("closure_span: found captured local {:?}", place);
 995                         let body = self.infcx.tcx.hir().body(body);
 996                         let generator_kind = body.generator_kind();
 997
 998                         return Some((
 999                             fn_decl_span,
1000                             generator_kind,
1001                             captured_place.get_capture_kind_span(self.infcx.tcx),
1002                             captured_place.get_path_span(self.infcx.tcx),
1003                         ));
1004                     }
1005                     _ => {}
1006                 }
1007             }
1008         }
1009         None
1010     }
1011
1012     /// Helper to retrieve span(s) of given borrow from the current MIR
1013     /// representation
1014     pub(super) fn retrieve_borrow_spans(&self, borrow: &BorrowData<'_>) -> UseSpans<'tcx> {
1015         let span = self.body.source_info(borrow.reserve_location).span;
1016         self.borrow_spans(span, borrow.reserve_location)
1017     }
1018
1019     fn explain_captures(
1020         &mut self,
1021         err: &mut Diagnostic,
1022         span: Span,
1023         move_span: Span,
1024         move_spans: UseSpans<'tcx>,
1025         moved_place: Place<'tcx>,
1026         partially_str: &str,
1027         loop_message: &str,
1028         move_msg: &str,
1029         is_loop_move: bool,
1030         maybe_reinitialized_locations_is_empty: bool,
1031     ) {
1032         if let UseSpans::FnSelfUse { var_span, fn_call_span, fn_span, kind } = move_spans {
1033             let place_name = self
1034                 .describe_place(moved_place.as_ref())
1035                 .map(|n| format!("`{n}`"))
1036                 .unwrap_or_else(|| "value".to_owned());
1037             match kind {
1038                 CallKind::FnCall { fn_trait_id, .. }
1039                     if Some(fn_trait_id) == self.infcx.tcx.lang_items().fn_once_trait() =>
1040                 {
1041                     err.span_label(
1042                         fn_call_span,
1043                         &format!(
1044                             "{place_name} {partially_str}moved due to this call{loop_message}",
1045                         ),
1046                     );
1047                     err.span_note(
1048                         var_span,
1049                         "this value implements `FnOnce`, which causes it to be moved when called",
1050                     );
1051                 }
1052                 CallKind::Operator { self_arg, .. } => {
1053                     let self_arg = self_arg.unwrap();
1054                     err.span_label(
1055                         fn_call_span,
1056                         &format!(
1057                             "{place_name} {partially_str}moved due to usage in operator{loop_message}",
1058                         ),
1059                     );
1060                     if self.fn_self_span_reported.insert(fn_span) {
1061                         err.span_note(
1062                             self_arg.span,
1063                             "calling this operator moves the left-hand side",
1064                         );
1065                     }
1066                 }
1067                 CallKind::Normal { self_arg, desugaring, method_did, method_substs } => {
1068                     let self_arg = self_arg.unwrap();
1069                     let tcx = self.infcx.tcx;
1070                     if let Some((CallDesugaringKind::ForLoopIntoIter, _)) = desugaring {
1071                         let ty = moved_place.ty(self.body, tcx).ty;
1072                         let suggest = match tcx.get_diagnostic_item(sym::IntoIterator) {
1073                             Some(def_id) => {
1074                                 let infcx = self.infcx.tcx.infer_ctxt().build();
1075                                 type_known_to_meet_bound_modulo_regions(
1076                                     &infcx,
1077                                     self.param_env,
1078                                     tcx.mk_imm_ref(tcx.lifetimes.re_erased, tcx.erase_regions(ty)),
1079                                     def_id,
1080                                     DUMMY_SP,
1081                                 )
1082                             }
1083                             _ => false,
1084                         };
1085                         if suggest {
1086                             err.span_suggestion_verbose(
1087                                 move_span.shrink_to_lo(),
1088                                 &format!(
1089                                     "consider iterating over a slice of the `{ty}`'s content to \
1090                                      avoid moving into the `for` loop",
1091                                 ),
1092                                 "&",
1093                                 Applicability::MaybeIncorrect,
1094                             );
1095                         }
1096
1097                         err.span_label(
1098                             fn_call_span,
1099                             &format!(
1100                                 "{place_name} {partially_str}moved due to this implicit call to `.into_iter()`{loop_message}",
1101                             ),
1102                         );
1103                         // If the moved place was a `&mut` ref, then we can
1104                         // suggest to reborrow it where it was moved, so it
1105                         // will still be valid by the time we get to the usage.
1106                         if let ty::Ref(_, _, hir::Mutability::Mut) =
1107                             moved_place.ty(self.body, self.infcx.tcx).ty.kind()
1108                         {
1109                             // If we are in a loop this will be suggested later.
1110                             if !is_loop_move {
1111                                 err.span_suggestion_verbose(
1112                                     move_span.shrink_to_lo(),
1113                                     &format!(
1114                                         "consider creating a fresh reborrow of {} here",
1115                                         self.describe_place(moved_place.as_ref())
1116                                             .map(|n| format!("`{n}`"))
1117                                             .unwrap_or_else(|| "the mutable reference".to_string()),
1118                                     ),
1119                                     "&mut *",
1120                                     Applicability::MachineApplicable,
1121                                 );
1122                             }
1123                         }
1124                     } else {
1125                         err.span_label(
1126                             fn_call_span,
1127                             &format!(
1128                                 "{place_name} {partially_str}moved due to this method call{loop_message}",
1129                             ),
1130                         );
1131                         let infcx = tcx.infer_ctxt().build();
1132                         let ty = tcx.erase_regions(moved_place.ty(self.body, tcx).ty);
1133                         if let ty::Adt(def, substs) = ty.kind()
1134                             && Some(def.did()) == tcx.lang_items().pin_type()
1135                             && let ty::Ref(_, _, hir::Mutability::Mut) = substs.type_at(0).kind()
1136                             && let self_ty = infcx.replace_bound_vars_with_fresh_vars(
1137                                 fn_call_span,
1138                                 LateBoundRegionConversionTime::FnCall,
1139                                 tcx.fn_sig(method_did).subst(tcx, method_substs).input(0),
1140                             )
1141                             && infcx.can_eq(self.param_env, ty, self_ty).is_ok()
1142                         {
1143                             err.span_suggestion_verbose(
1144                                 fn_call_span.shrink_to_lo(),
1145                                 "consider reborrowing the `Pin` instead of moving it",
1146                                 "as_mut().".to_string(),
1147                                 Applicability::MaybeIncorrect,
1148                             );
1149                         }
1150                         if let Some(clone_trait) = tcx.lang_items().clone_trait()
1151                             && let trait_ref = tcx.mk_trait_ref(clone_trait, [ty])
1152                             && let o = Obligation::new(
1153                                 tcx,
1154                                 ObligationCause::dummy(),
1155                                 self.param_env,
1156                                 ty::Binder::dummy(trait_ref),
1157                             )
1158                             && infcx.predicate_must_hold_modulo_regions(&o)
1159                         {
1160                             err.span_suggestion_verbose(
1161                                 fn_call_span.shrink_to_lo(),
1162                                 "you can `clone` the value and consume it, but this might not be \
1163                                  your desired behavior",
1164                                 "clone().".to_string(),
1165                                 Applicability::MaybeIncorrect,
1166                             );
1167                         }
1168                     }
1169                     // Avoid pointing to the same function in multiple different
1170                     // error messages.
1171                     if span != DUMMY_SP && self.fn_self_span_reported.insert(self_arg.span) {
1172                         let func = tcx.def_path_str(method_did);
1173                         err.span_note(
1174                             self_arg.span,
1175                             &format!("`{func}` takes ownership of the receiver `self`, which moves {place_name}")
1176                         );
1177                     }
1178                     let parent_did = tcx.parent(method_did);
1179                     let parent_self_ty = (tcx.def_kind(parent_did)
1180                         == rustc_hir::def::DefKind::Impl)
1181                         .then_some(parent_did)
1182                         .and_then(|did| match tcx.type_of(did).kind() {
1183                             ty::Adt(def, ..) => Some(def.did()),
1184                             _ => None,
1185                         });
1186                     let is_option_or_result = parent_self_ty.map_or(false, |def_id| {
1187                         matches!(tcx.get_diagnostic_name(def_id), Some(sym::Option | sym::Result))
1188                     });
1189                     if is_option_or_result && maybe_reinitialized_locations_is_empty {
1190                         err.span_label(
1191                             var_span,
1192                             "help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents",
1193                         );
1194                     }
1195                 }
1196                 // Other desugarings takes &self, which cannot cause a move
1197                 _ => {}
1198             }
1199         } else {
1200             if move_span != span || !loop_message.is_empty() {
1201                 err.span_label(
1202                     move_span,
1203                     format!("value {partially_str}moved{move_msg} here{loop_message}"),
1204                 );
1205             }
1206             // If the move error occurs due to a loop, don't show
1207             // another message for the same span
1208             if loop_message.is_empty() {
1209                 move_spans.var_span_label(
1210                     err,
1211                     format!("variable {partially_str}moved due to use{}", move_spans.describe()),
1212                     "moved",
1213                 );
1214             }
1215         }
1216     }
1217 }