1#![allow(rustc::diagnostic_outside_of_impl)]
2#![allow(rustc::untranslatable_diagnostic)]
3
4use core::ops::ControlFlow;
5
6use hir::{ExprKind, Param};
7use rustc_abi::FieldIdx;
8use rustc_errors::{Applicability, Diag};
9use rustc_hir::intravisit::Visitor;
10use rustc_hir::{self as hir, BindingMode, ByRef, Node};
11use rustc_middle::bug;
12use rustc_middle::hir::place::PlaceBase;
13use rustc_middle::mir::visit::PlaceContext;
14use rustc_middle::mir::{
15 self, BindingForm, Local, LocalDecl, LocalInfo, LocalKind, Location, Mutability, Place,
16 PlaceRef, ProjectionElem,
17};
18use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt, Upcast};
19use rustc_span::{BytePos, DesugaringKind, Span, Symbol, kw, sym};
20use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
21use rustc_trait_selection::infer::InferCtxtExt;
22use rustc_trait_selection::traits;
23use tracing::debug;
24
25use crate::diagnostics::BorrowedContentSource;
26use crate::{MirBorrowckCtxt, session_diagnostics};
27
28#[derive(Copy, Clone, Debug, Eq, PartialEq)]
29pub(crate) enum AccessKind {
30 MutableBorrow,
31 Mutate,
32}
33
34impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
35 pub(crate) fn report_mutability_error(
36 &mut self,
37 access_place: Place<'tcx>,
38 span: Span,
39 the_place_err: PlaceRef<'tcx>,
40 error_access: AccessKind,
41 location: Location,
42 ) {
43 debug!(
44 "report_mutability_error(\
45 access_place={:?}, span={:?}, the_place_err={:?}, error_access={:?}, location={:?},\
46 )",
47 access_place, span, the_place_err, error_access, location,
48 );
49
50 let mut err;
51 let item_msg;
52 let reason;
53 let mut opt_source = None;
54 let access_place_desc = self.describe_any_place(access_place.as_ref());
55 debug!("report_mutability_error: access_place_desc={:?}", access_place_desc);
56
57 match the_place_err {
58 PlaceRef { local, projection: [] } => {
59 item_msg = access_place_desc;
60 if access_place.as_local().is_some() {
61 reason = ", as it is not declared as mutable".to_string();
62 } else {
63 let name = self.local_names[local].expect("immutable unnamed local");
64 reason = format!(", as `{name}` is not declared as mutable");
65 }
66 }
67
68 PlaceRef {
69 local,
70 projection: [proj_base @ .., ProjectionElem::Field(upvar_index, _)],
71 } => {
72 debug_assert!(is_closure_like(
73 Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty
74 ));
75
76 let imm_borrow_derefed = self.upvars[upvar_index.index()]
77 .place
78 .deref_tys()
79 .any(|ty| matches!(ty.kind(), ty::Ref(.., hir::Mutability::Not)));
80
81 if imm_borrow_derefed {
88 return;
90 } else {
91 item_msg = access_place_desc;
92 if self.is_upvar_field_projection(access_place.as_ref()).is_some() {
93 reason = ", as it is not declared as mutable".to_string();
94 } else {
95 let name = self.upvars[upvar_index.index()].to_string(self.infcx.tcx);
96 reason = format!(", as `{name}` is not declared as mutable");
97 }
98 }
99 }
100
101 PlaceRef { local, projection: [ProjectionElem::Deref] }
102 if self.body.local_decls[local].is_ref_for_guard() =>
103 {
104 item_msg = access_place_desc;
105 reason = ", as it is immutable for the pattern guard".to_string();
106 }
107 PlaceRef { local, projection: [ProjectionElem::Deref] }
108 if self.body.local_decls[local].is_ref_to_static() =>
109 {
110 if access_place.projection.len() == 1 {
111 item_msg = format!("immutable static item {access_place_desc}");
112 reason = String::new();
113 } else {
114 item_msg = access_place_desc;
115 let local_info = self.body.local_decls[local].local_info();
116 if let LocalInfo::StaticRef { def_id, .. } = *local_info {
117 let static_name = &self.infcx.tcx.item_name(def_id);
118 reason = format!(", as `{static_name}` is an immutable static item");
119 } else {
120 bug!("is_ref_to_static return true, but not ref to static?");
121 }
122 }
123 }
124 PlaceRef { local: _, projection: [proj_base @ .., ProjectionElem::Deref] } => {
125 if the_place_err.local == ty::CAPTURE_STRUCT_LOCAL
126 && proj_base.is_empty()
127 && !self.upvars.is_empty()
128 {
129 item_msg = access_place_desc;
130 debug_assert!(self.body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty.is_ref());
131 debug_assert!(is_closure_like(the_place_err.ty(self.body, self.infcx.tcx).ty));
132
133 reason = if self.is_upvar_field_projection(access_place.as_ref()).is_some() {
134 ", as it is a captured variable in a `Fn` closure".to_string()
135 } else {
136 ", as `Fn` closures cannot mutate their captured variables".to_string()
137 }
138 } else {
139 let source = self.borrowed_content_source(PlaceRef {
140 local: the_place_err.local,
141 projection: proj_base,
142 });
143 let pointer_type = source.describe_for_immutable_place(self.infcx.tcx);
144 opt_source = Some(source);
145 if let Some(desc) = self.describe_place(access_place.as_ref()) {
146 item_msg = format!("`{desc}`");
147 reason = match error_access {
148 AccessKind::Mutate => format!(", which is behind {pointer_type}"),
149 AccessKind::MutableBorrow => {
150 format!(", as it is behind {pointer_type}")
151 }
152 }
153 } else {
154 item_msg = format!("data in {pointer_type}");
155 reason = String::new();
156 }
157 }
158 }
159
160 PlaceRef {
161 local: _,
162 projection:
163 [
164 ..,
165 ProjectionElem::Index(_)
166 | ProjectionElem::Subtype(_)
167 | ProjectionElem::ConstantIndex { .. }
168 | ProjectionElem::OpaqueCast { .. }
169 | ProjectionElem::Subslice { .. }
170 | ProjectionElem::Downcast(..)
171 | ProjectionElem::UnwrapUnsafeBinder(_),
172 ],
173 } => bug!("Unexpected immutable place."),
174 }
175
176 debug!("report_mutability_error: item_msg={:?}, reason={:?}", item_msg, reason);
177
178 let act;
181 let acted_on;
182 let mut suggest = true;
183 let mut mut_error = None;
184 let mut count = 1;
185
186 let span = match error_access {
187 AccessKind::Mutate => {
188 err = self.cannot_assign(span, &(item_msg + &reason));
189 act = "assign";
190 acted_on = "written";
191 span
192 }
193 AccessKind::MutableBorrow => {
194 act = "borrow as mutable";
195 acted_on = "borrowed as mutable";
196
197 let borrow_spans = self.borrow_spans(span, location);
198 let borrow_span = borrow_spans.args_or_use();
199 match the_place_err {
200 PlaceRef { local, projection: [] }
201 if self.body.local_decls[local].can_be_made_mutable() =>
202 {
203 let span = self.body.local_decls[local].source_info.span;
204 mut_error = Some(span);
205 if let Some((buffered_err, c)) = self.get_buffered_mut_error(span) {
206 err = buffered_err;
211 count = c + 1;
212 if count == 2 {
213 err.replace_span_with(span, false);
214 err.span_label(span, "not mutable");
215 }
216 suggest = false;
217 } else {
218 err = self.cannot_borrow_path_as_mutable_because(
219 borrow_span,
220 &item_msg,
221 &reason,
222 );
223 }
224 }
225 _ => {
226 err = self.cannot_borrow_path_as_mutable_because(
227 borrow_span,
228 &item_msg,
229 &reason,
230 );
231 }
232 }
233 if suggest {
234 borrow_spans.var_subdiag(
235 &mut err,
236 Some(mir::BorrowKind::Mut { kind: mir::MutBorrowKind::Default }),
237 |_kind, var_span| {
238 let place = self.describe_any_place(access_place.as_ref());
239 session_diagnostics::CaptureVarCause::MutableBorrowUsePlaceClosure {
240 place,
241 var_span,
242 }
243 },
244 );
245 }
246 borrow_span
247 }
248 };
249
250 debug!("report_mutability_error: act={:?}, acted_on={:?}", act, acted_on);
251
252 match the_place_err {
253 PlaceRef {
260 local,
261 projection:
262 [
263 proj_base @ ..,
264 ProjectionElem::Deref,
265 ProjectionElem::Field(field, _),
266 ProjectionElem::Deref,
267 ],
268 } => {
269 err.span_label(span, format!("cannot {act}"));
270
271 let place = Place::ty_from(local, proj_base, self.body, self.infcx.tcx);
272 if let Some(span) = get_mut_span_in_struct_field(self.infcx.tcx, place.ty, *field) {
273 err.span_suggestion_verbose(
274 span,
275 "consider changing this to be mutable",
276 " mut ",
277 Applicability::MaybeIncorrect,
278 );
279 }
280 }
281
282 PlaceRef { local, projection: [] }
284 if self
285 .body
286 .local_decls
287 .get(local)
288 .is_some_and(|l| mut_borrow_of_mutable_ref(l, self.local_names[local])) =>
289 {
290 let decl = &self.body.local_decls[local];
291 err.span_label(span, format!("cannot {act}"));
292 if let Some(mir::Statement {
293 source_info,
294 kind:
295 mir::StatementKind::Assign(box (
296 _,
297 mir::Rvalue::Ref(
298 _,
299 mir::BorrowKind::Mut { kind: mir::MutBorrowKind::Default },
300 _,
301 ),
302 )),
303 ..
304 }) = &self.body[location.block].statements.get(location.statement_index)
305 {
306 match *decl.local_info() {
307 LocalInfo::User(BindingForm::Var(mir::VarBindingForm {
308 binding_mode: BindingMode(ByRef::No, Mutability::Not),
309 opt_ty_info: Some(sp),
310 opt_match_place: _,
311 pat_span: _,
312 })) => {
313 if suggest {
314 err.span_note(sp, "the binding is already a mutable borrow");
315 }
316 }
317 _ => {
318 err.span_note(
319 decl.source_info.span,
320 "the binding is already a mutable borrow",
321 );
322 }
323 }
324 if let Ok(snippet) =
325 self.infcx.tcx.sess.source_map().span_to_snippet(source_info.span)
326 {
327 if snippet.starts_with("&mut ") {
328 err.span_suggestion_verbose(
331 source_info.span.with_hi(source_info.span.lo() + BytePos(5)),
332 "try removing `&mut` here",
333 "",
334 Applicability::MachineApplicable,
335 );
336 } else {
337 err.span_help(source_info.span, "try removing `&mut` here");
339 }
340 } else {
341 err.span_help(source_info.span, "try removing `&mut` here");
342 }
343 } else if decl.mutability.is_not() {
344 if matches!(
345 decl.local_info(),
346 LocalInfo::User(BindingForm::ImplicitSelf(hir::ImplicitSelfKind::RefMut))
347 ) {
348 err.note(
349 "as `Self` may be unsized, this call attempts to take `&mut &mut self`",
350 );
351 err.note("however, `&mut self` expands to `self: &mut Self`, therefore `self` cannot be borrowed mutably");
352 } else {
353 err.span_suggestion_verbose(
354 decl.source_info.span.shrink_to_lo(),
355 "consider making the binding mutable",
356 "mut ",
357 Applicability::MachineApplicable,
358 );
359 };
360 }
361 }
362
363 PlaceRef { local, projection: [] }
366 if self.body.local_decls[local].can_be_made_mutable() =>
367 {
368 let local_decl = &self.body.local_decls[local];
373 assert_eq!(local_decl.mutability, Mutability::Not);
374
375 if count < 10 {
376 err.span_label(span, format!("cannot {act}"));
377 }
378 if suggest {
379 self.construct_mut_suggestion_for_local_binding_patterns(&mut err, local);
380 let tcx = self.infcx.tcx;
381 if let ty::Closure(id, _) = *the_place_err.ty(self.body, tcx).ty.kind() {
382 self.show_mutating_upvar(tcx, id.expect_local(), the_place_err, &mut err);
383 }
384 }
385 }
386
387 PlaceRef {
389 local,
390 projection: [proj_base @ .., ProjectionElem::Field(upvar_index, _)],
391 } => {
392 debug_assert!(is_closure_like(
393 Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty
394 ));
395
396 let captured_place = self.upvars[upvar_index.index()];
397
398 err.span_label(span, format!("cannot {act}"));
399
400 let upvar_hir_id = captured_place.get_root_variable();
401
402 if let Node::Pat(pat) = self.infcx.tcx.hir_node(upvar_hir_id)
403 && let hir::PatKind::Binding(hir::BindingMode::NONE, _, upvar_ident, _) =
404 pat.kind
405 {
406 if upvar_ident.name == kw::SelfLower {
407 for (_, node) in self.infcx.tcx.hir_parent_iter(upvar_hir_id) {
408 if let Some(fn_decl) = node.fn_decl() {
409 if !matches!(
410 fn_decl.implicit_self,
411 hir::ImplicitSelfKind::RefImm | hir::ImplicitSelfKind::RefMut
412 ) {
413 err.span_suggestion_verbose(
414 upvar_ident.span.shrink_to_lo(),
415 "consider changing this to be mutable",
416 "mut ",
417 Applicability::MachineApplicable,
418 );
419 break;
420 }
421 }
422 }
423 } else {
424 err.span_suggestion_verbose(
425 upvar_ident.span.shrink_to_lo(),
426 "consider changing this to be mutable",
427 "mut ",
428 Applicability::MachineApplicable,
429 );
430 }
431 }
432
433 let tcx = self.infcx.tcx;
434 if let ty::Ref(_, ty, Mutability::Mut) = the_place_err.ty(self.body, tcx).ty.kind()
435 && let ty::Closure(id, _) = *ty.kind()
436 {
437 self.show_mutating_upvar(tcx, id.expect_local(), the_place_err, &mut err);
438 }
439 }
440
441 PlaceRef { local: _, projection: [] }
445 if self
446 .infcx
447 .tcx
448 .sess
449 .source_map()
450 .span_to_snippet(span)
451 .is_ok_and(|snippet| snippet.starts_with("&mut ")) =>
452 {
453 err.span_label(span, format!("cannot {act}"));
454 err.span_suggestion_verbose(
455 span.with_hi(span.lo() + BytePos(5)),
456 "try removing `&mut` here",
457 "",
458 Applicability::MaybeIncorrect,
459 );
460 }
461
462 PlaceRef { local, projection: [ProjectionElem::Deref] }
463 if self.body.local_decls[local].is_ref_for_guard() =>
464 {
465 err.span_label(span, format!("cannot {act}"));
466 err.note(
467 "variables bound in patterns are immutable until the end of the pattern guard",
468 );
469 }
470
471 PlaceRef { local, projection: [ProjectionElem::Deref] }
477 if self.body.local_decls[local].is_user_variable() =>
478 {
479 let local_decl = &self.body.local_decls[local];
480
481 let (pointer_sigil, pointer_desc) =
482 if local_decl.ty.is_ref() { ("&", "reference") } else { ("*const", "pointer") };
483
484 match self.local_names[local] {
485 Some(name) if !local_decl.from_compiler_desugaring() => {
486 err.span_label(
487 span,
488 format!(
489 "`{name}` is a `{pointer_sigil}` {pointer_desc}, \
490 so the data it refers to cannot be {acted_on}",
491 ),
492 );
493
494 self.suggest_using_iter_mut(&mut err);
495 self.suggest_make_local_mut(&mut err, local, name);
496 }
497 _ => {
498 err.span_label(
499 span,
500 format!("cannot {act} through `{pointer_sigil}` {pointer_desc}"),
501 );
502 }
503 }
504 }
505
506 PlaceRef { local, projection: [ProjectionElem::Deref] }
507 if local == ty::CAPTURE_STRUCT_LOCAL && !self.upvars.is_empty() =>
508 {
509 self.expected_fn_found_fn_mut_call(&mut err, span, act);
510 }
511
512 PlaceRef { local: _, projection: [.., ProjectionElem::Deref] } => {
513 err.span_label(span, format!("cannot {act}"));
514
515 match opt_source {
516 Some(BorrowedContentSource::OverloadedDeref(ty)) => {
517 err.help(format!(
518 "trait `DerefMut` is required to modify through a dereference, \
519 but it is not implemented for `{ty}`",
520 ));
521 }
522 Some(BorrowedContentSource::OverloadedIndex(ty)) => {
523 err.help(format!(
524 "trait `IndexMut` is required to modify indexed content, \
525 but it is not implemented for `{ty}`",
526 ));
527 self.suggest_map_index_mut_alternatives(ty, &mut err, span);
528 }
529 _ => (),
530 }
531 }
532
533 _ => {
534 err.span_label(span, format!("cannot {act}"));
535 }
536 }
537
538 if let Some(span) = mut_error {
539 self.buffer_mut_error(span, err, count);
540 } else {
541 self.buffer_error(err);
542 }
543 }
544
545 fn suggest_map_index_mut_alternatives(&self, ty: Ty<'tcx>, err: &mut Diag<'infcx>, span: Span) {
547 let Some(adt) = ty.ty_adt_def() else { return };
548 let did = adt.did();
549 if self.infcx.tcx.is_diagnostic_item(sym::HashMap, did)
550 || self.infcx.tcx.is_diagnostic_item(sym::BTreeMap, did)
551 {
552 struct SuggestIndexOperatorAlternativeVisitor<'a, 'infcx, 'tcx> {
556 assign_span: Span,
557 err: &'a mut Diag<'infcx>,
558 ty: Ty<'tcx>,
559 suggested: bool,
560 }
561 impl<'a, 'infcx, 'tcx> Visitor<'tcx> for SuggestIndexOperatorAlternativeVisitor<'a, 'infcx, 'tcx> {
562 fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
563 hir::intravisit::walk_stmt(self, stmt);
564 let expr = match stmt.kind {
565 hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr) => expr,
566 hir::StmtKind::Let(hir::LetStmt { init: Some(expr), .. }) => expr,
567 _ => {
568 return;
569 }
570 };
571 if let hir::ExprKind::Assign(place, rv, _sp) = expr.kind
572 && let hir::ExprKind::Index(val, index, _) = place.kind
573 && (expr.span == self.assign_span || place.span == self.assign_span)
574 {
575 self.err.multipart_suggestions(
578 format!(
579 "use `.insert()` to insert a value into a `{}`, `.get_mut()` \
580 to modify it, or the entry API for more flexibility",
581 self.ty,
582 ),
583 vec![
584 vec![
585 (
587 val.span.shrink_to_hi().with_hi(index.span.lo()),
588 ".insert(".to_string(),
589 ),
590 (
591 index.span.shrink_to_hi().with_hi(rv.span.lo()),
592 ", ".to_string(),
593 ),
594 (rv.span.shrink_to_hi(), ")".to_string()),
595 ],
596 vec![
597 (val.span.shrink_to_lo(), "if let Some(val) = ".to_string()),
599 (
600 val.span.shrink_to_hi().with_hi(index.span.lo()),
601 ".get_mut(".to_string(),
602 ),
603 (
604 index.span.shrink_to_hi().with_hi(place.span.hi()),
605 ") { *val".to_string(),
606 ),
607 (rv.span.shrink_to_hi(), "; }".to_string()),
608 ],
609 vec![
610 (val.span.shrink_to_lo(), "let val = ".to_string()),
612 (
613 val.span.shrink_to_hi().with_hi(index.span.lo()),
614 ".entry(".to_string(),
615 ),
616 (
617 index.span.shrink_to_hi().with_hi(rv.span.lo()),
618 ").or_insert(".to_string(),
619 ),
620 (rv.span.shrink_to_hi(), ")".to_string()),
621 ],
622 ],
623 Applicability::MachineApplicable,
624 );
625 self.suggested = true;
626 } else if let hir::ExprKind::MethodCall(_path, receiver, _, sp) = expr.kind
627 && let hir::ExprKind::Index(val, index, _) = receiver.kind
628 && receiver.span == self.assign_span
629 {
630 self.err.multipart_suggestion(
632 format!("to modify a `{}` use `.get_mut()`", self.ty),
633 vec![
634 (val.span.shrink_to_lo(), "if let Some(val) = ".to_string()),
635 (
636 val.span.shrink_to_hi().with_hi(index.span.lo()),
637 ".get_mut(".to_string(),
638 ),
639 (
640 index.span.shrink_to_hi().with_hi(receiver.span.hi()),
641 ") { val".to_string(),
642 ),
643 (sp.shrink_to_hi(), "; }".to_string()),
644 ],
645 Applicability::MachineApplicable,
646 );
647 self.suggested = true;
648 }
649 }
650 }
651 let def_id = self.body.source.def_id();
652 let Some(local_def_id) = def_id.as_local() else { return };
653 let Some(body) = self.infcx.tcx.hir_maybe_body_owned_by(local_def_id) else { return };
654
655 let mut v = SuggestIndexOperatorAlternativeVisitor {
656 assign_span: span,
657 err,
658 ty,
659 suggested: false,
660 };
661 v.visit_body(&body);
662 if !v.suggested {
663 err.help(format!(
664 "to modify a `{ty}`, use `.get_mut()`, `.insert()` or the entry API",
665 ));
666 }
667 }
668 }
669
670 fn is_error_in_trait(&self, local: Local) -> (bool, bool, Option<Span>) {
680 if self.body.local_kind(local) != LocalKind::Arg {
681 return (false, false, None);
682 }
683 let my_def = self.body.source.def_id();
684 let my_hir = self.infcx.tcx.local_def_id_to_hir_id(my_def.as_local().unwrap());
685 let Some(td) =
686 self.infcx.tcx.impl_of_method(my_def).and_then(|x| self.infcx.tcx.trait_id_of_impl(x))
687 else {
688 return (false, false, None);
689 };
690 (
691 true,
692 td.is_local(),
693 td.as_local().and_then(|tld| match self.infcx.tcx.hir_node_by_def_id(tld) {
694 Node::Item(hir::Item { kind: hir::ItemKind::Trait(_, _, _, _, items), .. }) => {
695 let mut f_in_trait_opt = None;
696 for hir::TraitItemRef { id: fi, kind: k, .. } in *items {
697 let hi = fi.hir_id();
698 if !matches!(k, hir::AssocItemKind::Fn { .. }) {
699 continue;
700 }
701 if self.infcx.tcx.hir_name(hi) != self.infcx.tcx.hir_name(my_hir) {
702 continue;
703 }
704 f_in_trait_opt = Some(hi);
705 break;
706 }
707 f_in_trait_opt.and_then(|f_in_trait| {
708 if let Node::TraitItem(ti) = self.infcx.tcx.hir_node(f_in_trait)
709 && let hir::TraitItemKind::Fn(sig, _) = ti.kind
710 && let Some(ty) = sig.decl.inputs.get(local.index() - 1)
711 && let hir::TyKind::Ref(_, mut_ty) = ty.kind
712 && let hir::Mutability::Not = mut_ty.mutbl
713 && sig.decl.implicit_self.has_implicit_self()
714 {
715 Some(ty.span)
716 } else {
717 None
718 }
719 })
720 }
721 _ => None,
722 }),
723 )
724 }
725
726 fn construct_mut_suggestion_for_local_binding_patterns(
727 &self,
728 err: &mut Diag<'_>,
729 local: Local,
730 ) {
731 let local_decl = &self.body.local_decls[local];
732 debug!("local_decl: {:?}", local_decl);
733 let pat_span = match *local_decl.local_info() {
734 LocalInfo::User(BindingForm::Var(mir::VarBindingForm {
735 binding_mode: BindingMode(ByRef::No, Mutability::Not),
736 opt_ty_info: _,
737 opt_match_place: _,
738 pat_span,
739 })) => pat_span,
740 _ => local_decl.source_info.span,
741 };
742
743 let def_id = self.body.source.def_id();
750 if let Some(local_def_id) = def_id.as_local()
751 && let Some(body) = self.infcx.tcx.hir_maybe_body_owned_by(local_def_id)
752 && let Some(hir_id) = (BindingFinder { span: pat_span }).visit_body(&body).break_value()
753 && let node = self.infcx.tcx.hir_node(hir_id)
754 && let hir::Node::LetStmt(hir::LetStmt {
755 pat: hir::Pat { kind: hir::PatKind::Ref(_, _), .. },
756 ..
757 })
758 | hir::Node::Param(Param {
759 pat: hir::Pat { kind: hir::PatKind::Ref(_, _), .. },
760 ..
761 }) = node
762 {
763 err.multipart_suggestion(
764 "consider changing this to be mutable",
765 vec![
766 (pat_span.until(local_decl.source_info.span), "&(mut ".to_string()),
767 (
768 local_decl.source_info.span.shrink_to_hi().with_hi(pat_span.hi()),
769 ")".to_string(),
770 ),
771 ],
772 Applicability::MachineApplicable,
773 );
774 return;
775 }
776
777 err.span_suggestion_verbose(
778 local_decl.source_info.span.shrink_to_lo(),
779 "consider changing this to be mutable",
780 "mut ",
781 Applicability::MachineApplicable,
782 );
783 }
784
785 fn show_mutating_upvar(
787 &self,
788 tcx: TyCtxt<'_>,
789 closure_local_def_id: hir::def_id::LocalDefId,
790 the_place_err: PlaceRef<'tcx>,
791 err: &mut Diag<'_>,
792 ) {
793 let tables = tcx.typeck(closure_local_def_id);
794 if let Some((span, closure_kind_origin)) = tcx.closure_kind_origin(closure_local_def_id) {
795 let reason = if let PlaceBase::Upvar(upvar_id) = closure_kind_origin.base {
796 let upvar = ty::place_to_string_for_capture(tcx, closure_kind_origin);
797 let root_hir_id = upvar_id.var_path.hir_id;
798 let captured_places =
801 tables.closure_min_captures[&closure_local_def_id].get(&root_hir_id).unwrap();
802
803 let origin_projection = closure_kind_origin
804 .projections
805 .iter()
806 .map(|proj| proj.kind)
807 .collect::<Vec<_>>();
808 let mut capture_reason = String::new();
809 for captured_place in captured_places {
810 let captured_place_kinds = captured_place
811 .place
812 .projections
813 .iter()
814 .map(|proj| proj.kind)
815 .collect::<Vec<_>>();
816 if rustc_middle::ty::is_ancestor_or_same_capture(
817 &captured_place_kinds,
818 &origin_projection,
819 ) {
820 match captured_place.info.capture_kind {
821 ty::UpvarCapture::ByRef(
822 ty::BorrowKind::Mutable | ty::BorrowKind::UniqueImmutable,
823 ) => {
824 capture_reason = format!("mutable borrow of `{upvar}`");
825 }
826 ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {
827 capture_reason = format!("possible mutation of `{upvar}`");
828 }
829 _ => bug!("upvar `{upvar}` borrowed, but not mutably"),
830 }
831 break;
832 }
833 }
834 if capture_reason.is_empty() {
835 bug!("upvar `{upvar}` borrowed, but cannot find reason");
836 }
837 capture_reason
838 } else {
839 bug!("not an upvar")
840 };
841 err.span_label(
842 *span,
843 format!(
844 "calling `{}` requires mutable binding due to {}",
845 self.describe_place(the_place_err).unwrap(),
846 reason
847 ),
848 );
849 }
850 }
851
852 fn suggest_similar_mut_method_for_for_loop(&self, err: &mut Diag<'_>, span: Span) {
855 use hir::ExprKind::{AddrOf, Block, Call, MethodCall};
856 use hir::{BorrowKind, Expr};
857
858 let tcx = self.infcx.tcx;
859 struct Finder {
860 span: Span,
861 }
862
863 impl<'tcx> Visitor<'tcx> for Finder {
864 type Result = ControlFlow<&'tcx Expr<'tcx>>;
865 fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) -> Self::Result {
866 if e.span == self.span {
867 ControlFlow::Break(e)
868 } else {
869 hir::intravisit::walk_expr(self, e)
870 }
871 }
872 }
873 if let Some(body) = tcx.hir_maybe_body_owned_by(self.mir_def_id())
874 && let Block(block, _) = body.value.kind
875 {
876 if let ControlFlow::Break(expr) = (Finder { span }).visit_block(block)
880 && let Call(_, [expr]) = expr.kind
881 {
882 match expr.kind {
883 MethodCall(path_segment, _, _, span) => {
884 let opt_suggestions = tcx
887 .typeck(path_segment.hir_id.owner.def_id)
888 .type_dependent_def_id(expr.hir_id)
889 .and_then(|def_id| tcx.impl_of_method(def_id))
890 .map(|def_id| tcx.associated_items(def_id))
891 .map(|assoc_items| {
892 assoc_items
893 .in_definition_order()
894 .map(|assoc_item_def| assoc_item_def.ident(tcx))
895 .filter(|&ident| {
896 let original_method_ident = path_segment.ident;
897 original_method_ident != ident
898 && ident.as_str().starts_with(
899 &original_method_ident.name.to_string(),
900 )
901 })
902 .map(|ident| format!("{ident}()"))
903 .peekable()
904 });
905
906 if let Some(mut suggestions) = opt_suggestions
907 && suggestions.peek().is_some()
908 {
909 err.span_suggestions(
910 span,
911 "use mutable method",
912 suggestions,
913 Applicability::MaybeIncorrect,
914 );
915 }
916 }
917 AddrOf(BorrowKind::Ref, Mutability::Not, expr) => {
918 err.span_suggestion_verbose(
920 expr.span.shrink_to_lo(),
921 "use a mutable iterator instead",
922 "mut ",
923 Applicability::MachineApplicable,
924 );
925 }
926 _ => {}
927 }
928 }
929 }
930 }
931
932 fn expected_fn_found_fn_mut_call(&self, err: &mut Diag<'_>, sp: Span, act: &str) {
934 err.span_label(sp, format!("cannot {act}"));
935
936 let tcx = self.infcx.tcx;
937 let closure_id = self.mir_hir_id();
938 let closure_span = tcx.def_span(self.mir_def_id());
939 let fn_call_id = tcx.parent_hir_id(closure_id);
940 let node = tcx.hir_node(fn_call_id);
941 let def_id = tcx.hir_enclosing_body_owner(fn_call_id);
942 let mut look_at_return = true;
943
944 let get_call_details = || {
947 let hir::Node::Expr(hir::Expr { hir_id, kind, .. }) = node else {
948 return None;
949 };
950
951 let typeck_results = tcx.typeck(def_id);
952
953 match kind {
954 hir::ExprKind::Call(expr, args) => {
955 if let Some(ty::FnDef(def_id, _)) =
956 typeck_results.node_type_opt(expr.hir_id).as_ref().map(|ty| ty.kind())
957 {
958 Some((*def_id, expr.span, *args))
959 } else {
960 None
961 }
962 }
963 hir::ExprKind::MethodCall(_, _, args, span) => typeck_results
964 .type_dependent_def_id(*hir_id)
965 .map(|def_id| (def_id, *span, *args)),
966 _ => None,
967 }
968 };
969
970 if let Some((callee_def_id, call_span, call_args)) = get_call_details() {
973 let arg_pos = call_args
974 .iter()
975 .enumerate()
976 .filter(|(_, arg)| arg.hir_id == closure_id)
977 .map(|(pos, _)| pos)
978 .next();
979
980 let arg = match tcx.hir_get_if_local(callee_def_id) {
981 Some(
982 hir::Node::Item(hir::Item {
983 ident, kind: hir::ItemKind::Fn { sig, .. }, ..
984 })
985 | hir::Node::TraitItem(hir::TraitItem {
986 ident,
987 kind: hir::TraitItemKind::Fn(sig, _),
988 ..
989 })
990 | hir::Node::ImplItem(hir::ImplItem {
991 ident,
992 kind: hir::ImplItemKind::Fn(sig, _),
993 ..
994 }),
995 ) => Some(
996 arg_pos
997 .and_then(|pos| {
998 sig.decl.inputs.get(
999 pos + if sig.decl.implicit_self.has_implicit_self() {
1000 1
1001 } else {
1002 0
1003 },
1004 )
1005 })
1006 .map(|arg| arg.span)
1007 .unwrap_or(ident.span),
1008 ),
1009 _ => None,
1010 };
1011 if let Some(span) = arg {
1012 err.span_label(span, "change this to accept `FnMut` instead of `Fn`");
1013 err.span_label(call_span, "expects `Fn` instead of `FnMut`");
1014 err.span_label(closure_span, "in this closure");
1015 look_at_return = false;
1016 }
1017 }
1018
1019 if look_at_return && tcx.hir_get_fn_id_for_return_block(closure_id).is_some() {
1020 match tcx.hir_node_by_def_id(tcx.hir_get_parent_item(fn_call_id).def_id) {
1023 hir::Node::Item(hir::Item {
1024 ident, kind: hir::ItemKind::Fn { sig, .. }, ..
1025 })
1026 | hir::Node::TraitItem(hir::TraitItem {
1027 ident,
1028 kind: hir::TraitItemKind::Fn(sig, _),
1029 ..
1030 })
1031 | hir::Node::ImplItem(hir::ImplItem {
1032 ident,
1033 kind: hir::ImplItemKind::Fn(sig, _),
1034 ..
1035 }) => {
1036 err.span_label(ident.span, "");
1037 err.span_label(
1038 sig.decl.output.span(),
1039 "change this to return `FnMut` instead of `Fn`",
1040 );
1041 err.span_label(closure_span, "in this closure");
1042 }
1043 _ => {}
1044 }
1045 }
1046 }
1047
1048 fn suggest_using_iter_mut(&self, err: &mut Diag<'_>) {
1049 let source = self.body.source;
1050 if let InstanceKind::Item(def_id) = source.instance
1051 && let Some(Node::Expr(hir::Expr { hir_id, kind, .. })) =
1052 self.infcx.tcx.hir_get_if_local(def_id)
1053 && let ExprKind::Closure(hir::Closure { kind: hir::ClosureKind::Closure, .. }) = kind
1054 && let Node::Expr(expr) = self.infcx.tcx.parent_hir_node(*hir_id)
1055 {
1056 let mut cur_expr = expr;
1057 while let ExprKind::MethodCall(path_segment, recv, _, _) = cur_expr.kind {
1058 if path_segment.ident.name == sym::iter {
1059 let res = self
1061 .infcx
1062 .tcx
1063 .typeck(path_segment.hir_id.owner.def_id)
1064 .type_dependent_def_id(cur_expr.hir_id)
1065 .and_then(|def_id| self.infcx.tcx.impl_of_method(def_id))
1066 .map(|def_id| self.infcx.tcx.associated_items(def_id))
1067 .map(|assoc_items| {
1068 assoc_items.filter_by_name_unhygienic(sym::iter_mut).peekable()
1069 });
1070
1071 if let Some(mut res) = res
1072 && res.peek().is_some()
1073 {
1074 err.span_suggestion_verbose(
1075 path_segment.ident.span,
1076 "you may want to use `iter_mut` here",
1077 "iter_mut",
1078 Applicability::MaybeIncorrect,
1079 );
1080 }
1081 break;
1082 } else {
1083 cur_expr = recv;
1084 }
1085 }
1086 }
1087 }
1088
1089 fn find_assignments(&self, local: Local) -> Vec<Location> {
1092 use rustc_middle::mir::visit::Visitor;
1093
1094 struct FindLocalAssignmentVisitor {
1095 needle: Local,
1096 locations: Vec<Location>,
1097 }
1098
1099 impl<'tcx> Visitor<'tcx> for FindLocalAssignmentVisitor {
1100 fn visit_local(
1101 &mut self,
1102 local: Local,
1103 place_context: PlaceContext,
1104 location: Location,
1105 ) {
1106 if self.needle != local {
1107 return;
1108 }
1109
1110 if place_context.is_place_assignment() {
1111 self.locations.push(location);
1112 }
1113 }
1114 }
1115
1116 let mut visitor = FindLocalAssignmentVisitor { needle: local, locations: vec![] };
1117 visitor.visit_body(self.body);
1118 visitor.locations
1119 }
1120
1121 fn suggest_make_local_mut(&self, err: &mut Diag<'_>, local: Local, name: Symbol) {
1122 let local_decl = &self.body.local_decls[local];
1123
1124 let (pointer_sigil, pointer_desc) =
1125 if local_decl.ty.is_ref() { ("&", "reference") } else { ("*const", "pointer") };
1126
1127 let (is_trait_sig, is_local, local_trait) = self.is_error_in_trait(local);
1128
1129 if is_trait_sig && !is_local {
1130 err.span_label(
1132 local_decl.source_info.span,
1133 format!("this is an immutable {pointer_desc}"),
1134 );
1135 return;
1136 }
1137 let decl_span = local_decl.source_info.span;
1138
1139 let amp_mut_sugg = match *local_decl.local_info() {
1140 LocalInfo::User(mir::BindingForm::ImplicitSelf(_)) => {
1141 let (span, suggestion) = suggest_ampmut_self(self.infcx.tcx, decl_span);
1142 let additional = local_trait.map(|span| suggest_ampmut_self(self.infcx.tcx, span));
1143 Some(AmpMutSugg { has_sugg: true, span, suggestion, additional })
1144 }
1145
1146 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm {
1147 binding_mode: BindingMode(ByRef::No, _),
1148 opt_ty_info,
1149 ..
1150 })) => {
1151 let opt_assignment_rhs_span =
1153 self.find_assignments(local).first().map(|&location| {
1154 if let Some(mir::Statement {
1155 source_info: _,
1156 kind:
1157 mir::StatementKind::Assign(box (
1158 _,
1159 mir::Rvalue::Use(mir::Operand::Copy(place)),
1160 )),
1161 }) = self.body[location.block].statements.get(location.statement_index)
1162 {
1163 self.body.local_decls[place.local].source_info.span
1164 } else {
1165 self.body.source_info(location).span
1166 }
1167 });
1168 match opt_assignment_rhs_span.and_then(|s| s.desugaring_kind()) {
1169 Some(DesugaringKind::ForLoop) => {
1171 let span = opt_assignment_rhs_span.unwrap();
1172 self.suggest_similar_mut_method_for_for_loop(err, span);
1173 err.span_label(
1174 span,
1175 format!("this iterator yields `{pointer_sigil}` {pointer_desc}s",),
1176 );
1177 None
1178 }
1179 Some(_) => None,
1181 None if opt_assignment_rhs_span
1183 .is_some_and(|span| self.infcx.tcx.sess.source_map().is_imported(span)) =>
1184 {
1185 None
1186 }
1187 None => {
1188 if name != kw::SelfLower {
1189 suggest_ampmut(
1190 self.infcx.tcx,
1191 local_decl.ty,
1192 decl_span,
1193 opt_assignment_rhs_span,
1194 opt_ty_info,
1195 )
1196 } else {
1197 match local_decl.local_info() {
1198 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm {
1199 opt_ty_info: None,
1200 ..
1201 })) => {
1202 let (span, sugg) =
1203 suggest_ampmut_self(self.infcx.tcx, decl_span);
1204 Some(AmpMutSugg {
1205 has_sugg: true,
1206 span,
1207 suggestion: sugg,
1208 additional: None,
1209 })
1210 }
1211 _ => suggest_ampmut(
1213 self.infcx.tcx,
1214 local_decl.ty,
1215 decl_span,
1216 opt_assignment_rhs_span,
1217 opt_ty_info,
1218 ),
1219 }
1220 }
1221 }
1222 }
1223 }
1224
1225 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm {
1226 binding_mode: BindingMode(ByRef::Yes(_), _),
1227 ..
1228 })) => {
1229 let pattern_span: Span = local_decl.source_info.span;
1230 suggest_ref_mut(self.infcx.tcx, pattern_span).map(|span| AmpMutSugg {
1231 has_sugg: true,
1232 span,
1233 suggestion: "mut ".to_owned(),
1234 additional: None,
1235 })
1236 }
1237
1238 _ => unreachable!(),
1239 };
1240
1241 match amp_mut_sugg {
1242 Some(AmpMutSugg {
1243 has_sugg: true,
1244 span: err_help_span,
1245 suggestion: suggested_code,
1246 additional,
1247 }) => {
1248 let mut sugg = vec![(err_help_span, suggested_code)];
1249 if let Some(s) = additional {
1250 sugg.push(s);
1251 }
1252
1253 if sugg.iter().all(|(span, _)| !self.infcx.tcx.sess.source_map().is_imported(*span))
1254 {
1255 err.multipart_suggestion_verbose(
1256 format!(
1257 "consider changing this to be a mutable {pointer_desc}{}",
1258 if is_trait_sig {
1259 " in the `impl` method and the `trait` definition"
1260 } else {
1261 ""
1262 }
1263 ),
1264 sugg,
1265 Applicability::MachineApplicable,
1266 );
1267 }
1268 }
1269 Some(AmpMutSugg {
1270 has_sugg: false, span: err_label_span, suggestion: message, ..
1271 }) => {
1272 let def_id = self.body.source.def_id();
1273 let hir_id = if let Some(local_def_id) = def_id.as_local()
1274 && let Some(body) = self.infcx.tcx.hir_maybe_body_owned_by(local_def_id)
1275 {
1276 BindingFinder { span: err_label_span }.visit_body(&body).break_value()
1277 } else {
1278 None
1279 };
1280
1281 if let Some(hir_id) = hir_id
1282 && let hir::Node::LetStmt(local) = self.infcx.tcx.hir_node(hir_id)
1283 {
1284 let tables = self.infcx.tcx.typeck(def_id.as_local().unwrap());
1285 if let Some(clone_trait) = self.infcx.tcx.lang_items().clone_trait()
1286 && let Some(expr) = local.init
1287 && let ty = tables.node_type_opt(expr.hir_id)
1288 && let Some(ty) = ty
1289 && let ty::Ref(..) = ty.kind()
1290 {
1291 match self
1292 .infcx
1293 .type_implements_trait_shallow(
1294 clone_trait,
1295 ty.peel_refs(),
1296 self.infcx.param_env,
1297 )
1298 .as_deref()
1299 {
1300 Some([]) => {
1301 }
1310 None => {
1311 if let hir::ExprKind::MethodCall(segment, _rcvr, [], span) =
1312 expr.kind
1313 && segment.ident.name == sym::clone
1314 {
1315 err.span_help(
1316 span,
1317 format!(
1318 "`{}` doesn't implement `Clone`, so this call clones \
1319 the reference `{ty}`",
1320 ty.peel_refs(),
1321 ),
1322 );
1323 }
1324 let trait_ref = ty::Binder::dummy(ty::TraitRef::new(
1326 self.infcx.tcx,
1327 clone_trait,
1328 [ty.peel_refs()],
1329 ));
1330 let obligation = traits::Obligation::new(
1331 self.infcx.tcx,
1332 traits::ObligationCause::dummy(),
1333 self.infcx.param_env,
1334 trait_ref,
1335 );
1336 self.infcx.err_ctxt().suggest_derive(
1337 &obligation,
1338 err,
1339 trait_ref.upcast(self.infcx.tcx),
1340 );
1341 }
1342 Some(errors) => {
1343 if let hir::ExprKind::MethodCall(segment, _rcvr, [], span) =
1344 expr.kind
1345 && segment.ident.name == sym::clone
1346 {
1347 err.span_help(
1348 span,
1349 format!(
1350 "`{}` doesn't implement `Clone` because its \
1351 implementations trait bounds could not be met, so \
1352 this call clones the reference `{ty}`",
1353 ty.peel_refs(),
1354 ),
1355 );
1356 err.note(format!(
1357 "the following trait bounds weren't met: {}",
1358 errors
1359 .iter()
1360 .map(|e| e.obligation.predicate.to_string())
1361 .collect::<Vec<_>>()
1362 .join("\n"),
1363 ));
1364 }
1365 for error in errors {
1367 if let traits::FulfillmentErrorCode::Select(
1368 traits::SelectionError::Unimplemented,
1369 ) = error.code
1370 && let ty::PredicateKind::Clause(ty::ClauseKind::Trait(
1371 pred,
1372 )) = error.obligation.predicate.kind().skip_binder()
1373 {
1374 self.infcx.err_ctxt().suggest_derive(
1375 &error.obligation,
1376 err,
1377 error.obligation.predicate.kind().rebind(pred),
1378 );
1379 }
1380 }
1381 }
1382 }
1383 }
1384 let (changing, span, sugg) = match local.ty {
1385 Some(ty) => ("changing", ty.span, message),
1386 None => {
1387 ("specifying", local.pat.span.shrink_to_hi(), format!(": {message}"))
1388 }
1389 };
1390 err.span_suggestion_verbose(
1391 span,
1392 format!("consider {changing} this binding's type"),
1393 sugg,
1394 Applicability::HasPlaceholders,
1395 );
1396 } else {
1397 err.span_label(
1398 err_label_span,
1399 format!("consider changing this binding's type to be: `{message}`"),
1400 );
1401 }
1402 }
1403 None => {}
1404 }
1405 }
1406}
1407
1408struct BindingFinder {
1409 span: Span,
1410}
1411
1412impl<'tcx> Visitor<'tcx> for BindingFinder {
1413 type Result = ControlFlow<hir::HirId>;
1414 fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) -> Self::Result {
1415 if let hir::StmtKind::Let(local) = s.kind
1416 && local.pat.span == self.span
1417 {
1418 ControlFlow::Break(local.hir_id)
1419 } else {
1420 hir::intravisit::walk_stmt(self, s)
1421 }
1422 }
1423
1424 fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) -> Self::Result {
1425 if let hir::Pat { kind: hir::PatKind::Ref(_, _), span, .. } = param.pat
1426 && *span == self.span
1427 {
1428 ControlFlow::Break(param.hir_id)
1429 } else {
1430 ControlFlow::Continue(())
1431 }
1432 }
1433}
1434
1435fn mut_borrow_of_mutable_ref(local_decl: &LocalDecl<'_>, local_name: Option<Symbol>) -> bool {
1436 debug!("local_info: {:?}, ty.kind(): {:?}", local_decl.local_info, local_decl.ty.kind());
1437
1438 match *local_decl.local_info() {
1439 LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm {
1441 binding_mode: BindingMode(ByRef::No, Mutability::Not),
1442 ..
1443 })) => matches!(local_decl.ty.kind(), ty::Ref(_, _, hir::Mutability::Mut)),
1444 LocalInfo::User(mir::BindingForm::ImplicitSelf(kind)) => {
1445 kind == hir::ImplicitSelfKind::RefMut
1451 }
1452 _ if Some(kw::SelfLower) == local_name => {
1453 matches!(local_decl.ty.kind(), ty::Ref(_, _, hir::Mutability::Mut))
1457 }
1458 _ => false,
1459 }
1460}
1461
1462fn suggest_ampmut_self(tcx: TyCtxt<'_>, span: Span) -> (Span, String) {
1463 match tcx.sess.source_map().span_to_snippet(span) {
1464 Ok(snippet) if snippet.ends_with("self") => {
1465 (span.with_hi(span.hi() - BytePos(4)).shrink_to_hi(), "mut ".to_string())
1466 }
1467 _ => (span, "&mut self".to_string()),
1468 }
1469}
1470
1471struct AmpMutSugg {
1472 has_sugg: bool,
1473 span: Span,
1474 suggestion: String,
1475 additional: Option<(Span, String)>,
1476}
1477
1478fn suggest_ampmut<'tcx>(
1494 tcx: TyCtxt<'tcx>,
1495 decl_ty: Ty<'tcx>,
1496 decl_span: Span,
1497 opt_assignment_rhs_span: Option<Span>,
1498 opt_ty_info: Option<Span>,
1499) -> Option<AmpMutSugg> {
1500 if let Some(rhs_span) = opt_assignment_rhs_span
1509 && let Ok(rhs_str) = tcx.sess.source_map().span_to_snippet(rhs_span)
1510 && let Some(rhs_str_no_amp) = rhs_str.strip_prefix('&')
1511 {
1512 if rhs_str_no_amp.trim_start().strip_prefix("raw const").is_some() {
1514 let const_idx = rhs_str.find("const").unwrap() as u32;
1515 let const_span = rhs_span
1516 .with_lo(rhs_span.lo() + BytePos(const_idx))
1517 .with_hi(rhs_span.lo() + BytePos(const_idx + "const".len() as u32));
1518
1519 return Some(AmpMutSugg {
1520 has_sugg: true,
1521 span: const_span,
1522 suggestion: "mut".to_owned(),
1523 additional: None,
1524 });
1525 }
1526
1527 let is_mut = if let Some(rest) = rhs_str_no_amp.trim_start().strip_prefix("mut") {
1529 match rest.chars().next() {
1530 Some(c) if c.is_whitespace() => true,
1532 Some('(') => true,
1534 Some('{') => true,
1536 _ => false,
1538 }
1539 } else {
1540 false
1541 };
1542 if !is_mut {
1545 let span = rhs_span.with_lo(rhs_span.lo() + BytePos(1)).shrink_to_lo();
1547
1548 return Some(AmpMutSugg {
1551 has_sugg: true,
1552 span,
1553 suggestion: "mut ".to_owned(),
1554 additional: None,
1555 });
1556 }
1557 }
1558
1559 let (binding_exists, span) = match opt_ty_info {
1560 Some(ty_span) => (true, ty_span),
1564
1565 None => (false, decl_span),
1569 };
1570
1571 if let Ok(src) = tcx.sess.source_map().span_to_snippet(span)
1575 && src.starts_with("&'")
1576 && let Some(ws_pos) = src.find(char::is_whitespace)
1578 {
1579 let span = span.with_lo(span.lo() + BytePos(ws_pos as u32)).shrink_to_lo();
1580 Some(AmpMutSugg { has_sugg: true, span, suggestion: " mut".to_owned(), additional: None })
1581 } else if binding_exists {
1583 let span = span.with_lo(span.lo() + BytePos(1)).shrink_to_lo();
1585 Some(AmpMutSugg { has_sugg: true, span, suggestion: "mut ".to_owned(), additional: None })
1586 } else {
1587 let ty = decl_ty.builtin_deref(true).unwrap();
1590
1591 Some(AmpMutSugg {
1592 has_sugg: false,
1593 span,
1594 suggestion: format!("{}mut {}", if decl_ty.is_ref() { "&" } else { "*" }, ty),
1595 additional: None,
1596 })
1597 }
1598}
1599
1600fn is_closure_like(ty: Ty<'_>) -> bool {
1602 ty.is_closure() || ty.is_coroutine() || ty.is_coroutine_closure()
1603}
1604
1605fn get_mut_span_in_struct_field<'tcx>(
1613 tcx: TyCtxt<'tcx>,
1614 ty: Ty<'tcx>,
1615 field: FieldIdx,
1616) -> Option<Span> {
1617 if let ty::Ref(_, ty, _) = ty.kind()
1619 && let ty::Adt(def, _) = ty.kind()
1620 && let field = def.all_fields().nth(field.index())?
1621 && let hir::Node::Field(field) = tcx.hir_node_by_def_id(field.did.as_local()?)
1624 && let hir::TyKind::Ref(lt, hir::MutTy { mutbl: hir::Mutability::Not, ty }) = field.ty.kind
1625 {
1626 return Some(lt.ident.span.between(ty.span));
1627 }
1628
1629 None
1630}
1631
1632fn suggest_ref_mut(tcx: TyCtxt<'_>, span: Span) -> Option<Span> {
1634 let pattern_str = tcx.sess.source_map().span_to_snippet(span).ok()?;
1635 if pattern_str.starts_with("ref")
1636 && pattern_str["ref".len()..].starts_with(rustc_lexer::is_whitespace)
1637 {
1638 let span = span.with_lo(span.lo() + BytePos(4)).shrink_to_lo();
1639 Some(span)
1640 } else {
1641 None
1642 }
1643}