1 use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed};
2 use rustc_middle::mir::*;
4 use rustc_mir_dataflow::move_paths::{
5 IllegalMoveOrigin, IllegalMoveOriginKind, LookupResult, MoveError, MovePathIndex,
9 use crate::diagnostics::{DescribePlaceOpt, UseSpans};
10 use crate::prefixes::PrefixSet;
11 use crate::MirBorrowckCtxt;
13 // Often when desugaring a pattern match we may have many individual moves in
14 // MIR that are all part of one operation from the user's point-of-view. For
19 // would move x from the 0 field of some temporary, and y from the 1 field. We
20 // group such errors together for cleaner error reporting.
22 // Errors are kept separate if they are from places with different parent move
23 // paths. For example, this generates two errors:
25 // let (&x, &y) = (&String::new(), &String::new());
27 enum GroupedMoveError<'tcx> {
28 // Place expression can't be moved from,
29 // e.g., match x[0] { s => (), } where x: &[String]
31 original_path: Place<'tcx>,
33 move_from: Place<'tcx>,
34 kind: IllegalMoveOriginKind<'tcx>,
37 // Part of a value expression can't be moved from,
38 // e.g., match &String::new() { &x => (), }
40 original_path: Place<'tcx>,
42 move_from: MovePathIndex,
43 kind: IllegalMoveOriginKind<'tcx>,
46 // Everything that isn't from pattern matching.
48 original_path: Place<'tcx>,
49 use_spans: UseSpans<'tcx>,
50 kind: IllegalMoveOriginKind<'tcx>,
54 impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
55 pub(crate) fn report_move_errors(&mut self, move_errors: Vec<(Place<'tcx>, MoveError<'tcx>)>) {
56 let grouped_errors = self.group_move_errors(move_errors);
57 for error in grouped_errors {
64 errors: Vec<(Place<'tcx>, MoveError<'tcx>)>,
65 ) -> Vec<GroupedMoveError<'tcx>> {
66 let mut grouped_errors = Vec::new();
67 for (original_path, error) in errors {
68 self.append_to_grouped_errors(&mut grouped_errors, original_path, error);
73 fn append_to_grouped_errors(
75 grouped_errors: &mut Vec<GroupedMoveError<'tcx>>,
76 original_path: Place<'tcx>,
77 error: MoveError<'tcx>,
80 MoveError::UnionMove { .. } => {
81 unimplemented!("don't know how to report union move errors yet.")
83 MoveError::IllegalMove { cannot_move_out_of: IllegalMoveOrigin { location, kind } } => {
84 // Note: that the only time we assign a place isn't a temporary
85 // to a user variable is when initializing it.
86 // If that ever stops being the case, then the ever initialized
87 // flow could be used.
88 if let Some(StatementKind::Assign(box (
90 Rvalue::Use(Operand::Move(move_from)),
91 ))) = self.body.basic_blocks[location.block]
93 .get(location.statement_index)
94 .map(|stmt| &stmt.kind)
96 if let Some(local) = place.as_local() {
97 let local_decl = &self.body.local_decls[local];
98 // opt_match_place is the
99 // match_span is the span of the expression being matched on
100 // match *x.y { ... } match_place is Some(*x.y)
101 // ^^^^ match_span is the span of *x.y
103 // opt_match_place is None for let [mut] x = ... statements,
104 // whether or not the right-hand side is a place expression
105 if let Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(
107 opt_match_place: Some((opt_match_place, match_span)),
112 )))) = local_decl.local_info
114 let stmt_source_info = self.body.source_info(location);
115 self.append_binding_error(
123 stmt_source_info.span,
130 let move_spans = self.move_spans(original_path.as_ref(), location);
131 grouped_errors.push(GroupedMoveError::OtherIllegalMove {
132 use_spans: move_spans,
140 fn append_binding_error(
142 grouped_errors: &mut Vec<GroupedMoveError<'tcx>>,
143 kind: IllegalMoveOriginKind<'tcx>,
144 original_path: Place<'tcx>,
145 move_from: Place<'tcx>,
147 match_place: Option<Place<'tcx>>,
149 statement_span: Span,
151 debug!("append_binding_error(match_place={:?}, match_span={:?})", match_place, match_span);
153 let from_simple_let = match_place.is_none();
154 let match_place = match_place.unwrap_or(move_from);
156 match self.move_data.rev_lookup.find(match_place.as_ref()) {
157 // Error with the match place
158 LookupResult::Parent(_) => {
159 for ge in &mut *grouped_errors {
160 if let GroupedMoveError::MovesFromPlace { span, binds_to, .. } = ge
161 && match_span == *span
163 debug!("appending local({:?}) to list", bind_to);
164 if !binds_to.is_empty() {
165 binds_to.push(bind_to);
170 debug!("found a new move error location");
172 // Don't need to point to x in let x = ... .
173 let (binds_to, span) = if from_simple_let {
174 (vec![], statement_span)
176 (vec![bind_to], match_span)
178 grouped_errors.push(GroupedMoveError::MovesFromPlace {
186 // Error with the pattern
187 LookupResult::Exact(_) => {
188 let LookupResult::Parent(Some(mpi)) = self.move_data.rev_lookup.find(move_from.as_ref()) else {
189 // move_from should be a projection from match_place.
190 unreachable!("Probably not unreachable...");
192 for ge in &mut *grouped_errors {
193 if let GroupedMoveError::MovesFromValue {
195 move_from: other_mpi,
200 if match_span == *span && mpi == *other_mpi {
201 debug!("appending local({:?}) to list", bind_to);
202 binds_to.push(bind_to);
207 debug!("found a new move error location");
208 grouped_errors.push(GroupedMoveError::MovesFromValue {
213 binds_to: vec![bind_to],
219 fn report(&mut self, error: GroupedMoveError<'tcx>) {
220 let (mut err, err_span) = {
221 let (span, use_spans, original_path, kind) = match error {
222 GroupedMoveError::MovesFromPlace { span, original_path, ref kind, .. }
223 | GroupedMoveError::MovesFromValue { span, original_path, ref kind, .. } => {
224 (span, None, original_path, kind)
226 GroupedMoveError::OtherIllegalMove { use_spans, original_path, ref kind } => {
227 (use_spans.args_or_use(), Some(use_spans), original_path, kind)
231 "report: original_path={:?} span={:?}, kind={:?} \
232 original_path.is_upvar_field_projection={:?}",
236 self.is_upvar_field_projection(original_path.as_ref())
240 &IllegalMoveOriginKind::BorrowedContent { target_place } => self
241 .report_cannot_move_from_borrowed_content(
247 &IllegalMoveOriginKind::InteriorOfTypeWithDestructor { container_ty: ty } => {
248 self.cannot_move_out_of_interior_of_drop(span, ty)
250 &IllegalMoveOriginKind::InteriorOfSliceOrArray { ty, is_index } => {
251 self.cannot_move_out_of_interior_noncopy(span, ty, Some(is_index))
258 self.add_move_hints(error, &mut err, err_span);
259 self.buffer_error(err);
262 fn report_cannot_move_from_static(
266 ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
267 let description = if place.projection.len() == 1 {
268 format!("static item {}", self.describe_any_place(place.as_ref()))
270 let base_static = PlaceRef { local: place.local, projection: &[ProjectionElem::Deref] };
273 "{} as {} is a static item",
274 self.describe_any_place(place.as_ref()),
275 self.describe_any_place(base_static),
279 self.cannot_move_out_of(span, &description)
282 fn report_cannot_move_from_borrowed_content(
284 move_place: Place<'tcx>,
285 deref_target_place: Place<'tcx>,
287 use_spans: Option<UseSpans<'tcx>>,
288 ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
289 // Inspect the type of the content behind the
290 // borrow to provide feedback about why this
291 // was a move rather than a copy.
292 let ty = deref_target_place.ty(self.body, self.infcx.tcx).ty;
293 let upvar_field = self
294 .prefixes(move_place.as_ref(), PrefixSet::All)
295 .find_map(|p| self.is_upvar_field_projection(p));
297 let deref_base = match deref_target_place.projection.as_ref() {
298 [proj_base @ .., ProjectionElem::Deref] => {
299 PlaceRef { local: deref_target_place.local, projection: &proj_base }
301 _ => bug!("deref_target_place is not a deref projection"),
304 if let PlaceRef { local, projection: [] } = deref_base {
305 let decl = &self.body.local_decls[local];
306 if decl.is_ref_for_guard() {
307 let mut err = self.cannot_move_out_of(
309 &format!("`{}` in pattern guard", self.local_names[local].unwrap()),
312 "variables bound in patterns cannot be moved from \
313 until after the end of the pattern guard",
316 } else if decl.is_ref_to_static() {
317 return self.report_cannot_move_from_static(move_place, span);
321 debug!("report: ty={:?}", ty);
322 let mut err = match ty.kind() {
323 ty::Array(..) | ty::Slice(..) => {
324 self.cannot_move_out_of_interior_noncopy(span, ty, None)
326 ty::Closure(def_id, closure_substs)
327 if def_id.as_local() == Some(self.mir_def_id()) && upvar_field.is_some() =>
329 let closure_kind_ty = closure_substs.as_closure().kind_ty();
330 let closure_kind = match closure_kind_ty.to_opt_closure_kind() {
331 Some(kind @ (ty::ClosureKind::Fn | ty::ClosureKind::FnMut)) => kind,
332 Some(ty::ClosureKind::FnOnce) => {
333 bug!("closure kind does not match first argument type")
335 None => bug!("closure kind not inferred by borrowck"),
337 let capture_description =
338 format!("captured variable in an `{closure_kind}` closure");
340 let upvar = &self.upvars[upvar_field.unwrap().index()];
341 let upvar_hir_id = upvar.place.get_root_variable();
342 let upvar_name = upvar.place.to_string(self.infcx.tcx);
343 let upvar_span = self.infcx.tcx.hir().span(upvar_hir_id);
345 let place_name = self.describe_any_place(move_place.as_ref());
347 let place_description =
348 if self.is_upvar_field_projection(move_place.as_ref()).is_some() {
349 format!("{place_name}, a {capture_description}")
351 format!("{place_name}, as `{upvar_name}` is a {capture_description}")
355 "report: closure_kind_ty={:?} closure_kind={:?} place_description={:?}",
356 closure_kind_ty, closure_kind, place_description,
359 let mut diag = self.cannot_move_out_of(span, &place_description);
361 diag.span_label(upvar_span, "captured outer variable");
364 format!("captured by this `{closure_kind}` closure"),
370 let source = self.borrowed_content_source(deref_base);
371 let move_place_ref = move_place.as_ref();
373 self.describe_place_with_options(
376 including_downcast: false,
377 including_tuple_field: false,
380 self.describe_name(move_place_ref),
381 source.describe_for_named_place(),
383 (Some(place_desc), Some(name), Some(source_desc)) => self.cannot_move_out_of(
385 &format!("`{place_desc}` as enum variant `{name}` which is behind a {source_desc}"),
387 (Some(place_desc), Some(name), None) => self.cannot_move_out_of(
389 &format!("`{place_desc}` as enum variant `{name}`"),
391 (Some(place_desc), _, Some(source_desc)) => self.cannot_move_out_of(
393 &format!("`{place_desc}` which is behind a {source_desc}"),
395 (_, _, _) => self.cannot_move_out_of(
397 &source.describe_for_unnamed_place(self.infcx.tcx),
402 if let Some(use_spans) = use_spans {
403 self.explain_captures(
404 &mut err, span, span, use_spans, move_place, None, "", "", "", false, true,
410 fn add_move_hints(&self, error: GroupedMoveError<'tcx>, err: &mut Diagnostic, span: Span) {
412 GroupedMoveError::MovesFromPlace { mut binds_to, move_from, .. } => {
413 if let Ok(snippet) = self.infcx.tcx.sess.source_map().span_to_snippet(span) {
416 "consider borrowing here",
417 format!("&{snippet}"),
418 Applicability::Unspecified,
422 if binds_to.is_empty() {
423 let place_ty = move_from.ty(self.body, self.infcx.tcx).ty;
424 let place_desc = match self.describe_place(move_from.as_ref()) {
425 Some(desc) => format!("`{desc}`"),
426 None => "value".to_string(),
429 self.note_type_does_not_implement_copy(
440 self.add_move_error_details(err, &binds_to);
443 GroupedMoveError::MovesFromValue { mut binds_to, .. } => {
446 self.add_move_error_suggestions(err, &binds_to);
447 self.add_move_error_details(err, &binds_to);
449 // No binding. Nothing to suggest.
450 GroupedMoveError::OtherIllegalMove { ref original_path, use_spans, .. } => {
451 let span = use_spans.var_or_use();
452 let place_ty = original_path.ty(self.body, self.infcx.tcx).ty;
453 let place_desc = match self.describe_place(original_path.as_ref()) {
454 Some(desc) => format!("`{desc}`"),
455 None => "value".to_string(),
457 self.note_type_does_not_implement_copy(err, &place_desc, place_ty, Some(span), "");
459 use_spans.args_span_label(err, format!("move out of {place_desc} occurs here"));
464 fn add_move_error_suggestions(&self, err: &mut Diagnostic, binds_to: &[Local]) {
465 let mut suggestions: Vec<(Span, &str, String)> = Vec::new();
466 for local in binds_to {
467 let bind_to = &self.body.local_decls[*local];
468 if let Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(
469 VarBindingForm { pat_span, .. },
470 )))) = bind_to.local_info
472 if let Ok(pat_snippet) = self.infcx.tcx.sess.source_map().span_to_snippet(pat_span)
474 if let Some(stripped) = pat_snippet.strip_prefix('&') {
475 let pat_snippet = stripped.trim_start();
476 let (suggestion, to_remove) = if pat_snippet.starts_with("mut")
477 && pat_snippet["mut".len()..].starts_with(rustc_lexer::is_whitespace)
479 (pat_snippet["mut".len()..].trim_start(), "&mut")
483 suggestions.push((pat_span, to_remove, suggestion.to_owned()));
488 suggestions.sort_unstable_by_key(|&(span, _, _)| span);
489 suggestions.dedup_by_key(|&mut (span, _, _)| span);
490 for (span, to_remove, suggestion) in suggestions {
493 &format!("consider removing the `{to_remove}`"),
495 Applicability::MachineApplicable,
500 fn add_move_error_details(&self, err: &mut Diagnostic, binds_to: &[Local]) {
501 for (j, local) in binds_to.iter().enumerate() {
502 let bind_to = &self.body.local_decls[*local];
503 let binding_span = bind_to.source_info.span;
506 err.span_label(binding_span, "data moved here");
508 err.span_label(binding_span, "...and here");
511 if binds_to.len() == 1 {
512 self.note_type_does_not_implement_copy(
514 &format!("`{}`", self.local_names[*local].unwrap()),
522 if binds_to.len() > 1 {
524 "move occurs because these variables have types that \
525 don't implement the `Copy` trait",