| #![allow(rustc::diagnostic_outside_of_impl)] |
| #![allow(rustc::untranslatable_diagnostic)] |
| |
| use core::ops::ControlFlow; |
| use hir::{ExprKind, Param}; |
| use rustc_errors::{Applicability, Diag}; |
| use rustc_hir::intravisit::Visitor; |
| use rustc_hir::{self as hir, BindingMode, ByRef, Node}; |
| use rustc_infer::traits; |
| use rustc_middle::bug; |
| use rustc_middle::mir::{Mutability, Place, PlaceRef, ProjectionElem}; |
| use rustc_middle::ty::{self, InstanceDef, ToPredicate, Ty, TyCtxt}; |
| use rustc_middle::{ |
| hir::place::PlaceBase, |
| mir::{self, BindingForm, Local, LocalDecl, LocalInfo, LocalKind, Location}, |
| }; |
| use rustc_span::symbol::{kw, Symbol}; |
| use rustc_span::{sym, BytePos, DesugaringKind, Span}; |
| use rustc_target::abi::FieldIdx; |
| use rustc_trait_selection::infer::InferCtxtExt; |
| use rustc_trait_selection::traits::error_reporting::suggestions::TypeErrCtxtExt; |
| |
| use crate::diagnostics::BorrowedContentSource; |
| use crate::util::FindAssignments; |
| use crate::{session_diagnostics, MirBorrowckCtxt}; |
| |
| #[derive(Copy, Clone, Debug, Eq, PartialEq)] |
| pub(crate) enum AccessKind { |
| MutableBorrow, |
| Mutate, |
| } |
| |
| impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { |
| pub(crate) fn report_mutability_error( |
| &mut self, |
| access_place: Place<'tcx>, |
| span: Span, |
| the_place_err: PlaceRef<'tcx>, |
| error_access: AccessKind, |
| location: Location, |
| ) { |
| debug!( |
| "report_mutability_error(\ |
| access_place={:?}, span={:?}, the_place_err={:?}, error_access={:?}, location={:?},\ |
| )", |
| access_place, span, the_place_err, error_access, location, |
| ); |
| |
| let mut err; |
| let item_msg; |
| let reason; |
| let mut opt_source = None; |
| let access_place_desc = self.describe_any_place(access_place.as_ref()); |
| debug!("report_mutability_error: access_place_desc={:?}", access_place_desc); |
| |
| match the_place_err { |
| PlaceRef { local, projection: [] } => { |
| item_msg = access_place_desc; |
| if access_place.as_local().is_some() { |
| reason = ", as it is not declared as mutable".to_string(); |
| } else { |
| let name = self.local_names[local].expect("immutable unnamed local"); |
| reason = format!(", as `{name}` is not declared as mutable"); |
| } |
| } |
| |
| PlaceRef { |
| local, |
| projection: [proj_base @ .., ProjectionElem::Field(upvar_index, _)], |
| } => { |
| debug_assert!(is_closure_like( |
| Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty |
| )); |
| |
| let imm_borrow_derefed = self.upvars[upvar_index.index()] |
| .place |
| .deref_tys() |
| .any(|ty| matches!(ty.kind(), ty::Ref(.., hir::Mutability::Not))); |
| |
| // If the place is immutable then: |
| // |
| // - Either we deref an immutable ref to get to our final place. |
| // - We don't capture derefs of raw ptrs |
| // - Or the final place is immut because the root variable of the capture |
| // isn't marked mut and we should suggest that to the user. |
| if imm_borrow_derefed { |
| // If we deref an immutable ref then the suggestion here doesn't help. |
| return; |
| } else { |
| item_msg = access_place_desc; |
| if self.is_upvar_field_projection(access_place.as_ref()).is_some() { |
| reason = ", as it is not declared as mutable".to_string(); |
| } else { |
| let name = self.upvars[upvar_index.index()].to_string(self.infcx.tcx); |
| reason = format!(", as `{name}` is not declared as mutable"); |
| } |
| } |
| } |
| |
| PlaceRef { local, projection: [ProjectionElem::Deref] } |
| if self.body.local_decls[local].is_ref_for_guard() => |
| { |
| item_msg = access_place_desc; |
| reason = ", as it is immutable for the pattern guard".to_string(); |
| } |
| PlaceRef { local, projection: [ProjectionElem::Deref] } |
| if self.body.local_decls[local].is_ref_to_static() => |
| { |
| if access_place.projection.len() == 1 { |
| item_msg = format!("immutable static item {access_place_desc}"); |
| reason = String::new(); |
| } else { |
| item_msg = access_place_desc; |
| let local_info = self.body.local_decls[local].local_info(); |
| if let LocalInfo::StaticRef { def_id, .. } = *local_info { |
| let static_name = &self.infcx.tcx.item_name(def_id); |
| reason = format!(", as `{static_name}` is an immutable static item"); |
| } else { |
| bug!("is_ref_to_static return true, but not ref to static?"); |
| } |
| } |
| } |
| PlaceRef { local: _, projection: [proj_base @ .., ProjectionElem::Deref] } => { |
| if the_place_err.local == ty::CAPTURE_STRUCT_LOCAL |
| && proj_base.is_empty() |
| && !self.upvars.is_empty() |
| { |
| item_msg = access_place_desc; |
| debug_assert!(self.body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty.is_ref()); |
| debug_assert!(is_closure_like(the_place_err.ty(self.body, self.infcx.tcx).ty)); |
| |
| reason = if self.is_upvar_field_projection(access_place.as_ref()).is_some() { |
| ", as it is a captured variable in a `Fn` closure".to_string() |
| } else { |
| ", as `Fn` closures cannot mutate their captured variables".to_string() |
| } |
| } else { |
| let source = self.borrowed_content_source(PlaceRef { |
| local: the_place_err.local, |
| projection: proj_base, |
| }); |
| let pointer_type = source.describe_for_immutable_place(self.infcx.tcx); |
| opt_source = Some(source); |
| if let Some(desc) = self.describe_place(access_place.as_ref()) { |
| item_msg = format!("`{desc}`"); |
| reason = match error_access { |
| AccessKind::Mutate => format!(", which is behind {pointer_type}"), |
| AccessKind::MutableBorrow => { |
| format!(", as it is behind {pointer_type}") |
| } |
| } |
| } else { |
| item_msg = format!("data in {pointer_type}"); |
| reason = String::new(); |
| } |
| } |
| } |
| |
| PlaceRef { |
| local: _, |
| projection: |
| [ |
| .., |
| ProjectionElem::Index(_) |
| | ProjectionElem::Subtype(_) |
| | ProjectionElem::ConstantIndex { .. } |
| | ProjectionElem::OpaqueCast { .. } |
| | ProjectionElem::Subslice { .. } |
| | ProjectionElem::Downcast(..), |
| ], |
| } => bug!("Unexpected immutable place."), |
| } |
| |
| debug!("report_mutability_error: item_msg={:?}, reason={:?}", item_msg, reason); |
| |
| // `act` and `acted_on` are strings that let us abstract over |
| // the verbs used in some diagnostic messages. |
| let act; |
| let acted_on; |
| let mut suggest = true; |
| let mut mut_error = None; |
| let mut count = 1; |
| |
| let span = match error_access { |
| AccessKind::Mutate => { |
| err = self.cannot_assign(span, &(item_msg + &reason)); |
| act = "assign"; |
| acted_on = "written"; |
| span |
| } |
| AccessKind::MutableBorrow => { |
| act = "borrow as mutable"; |
| acted_on = "borrowed as mutable"; |
| |
| let borrow_spans = self.borrow_spans(span, location); |
| let borrow_span = borrow_spans.args_or_use(); |
| match the_place_err { |
| PlaceRef { local, projection: [] } |
| if self.body.local_decls[local].can_be_made_mutable() => |
| { |
| let span = self.body.local_decls[local].source_info.span; |
| mut_error = Some(span); |
| if let Some((buffered_err, c)) = self.get_buffered_mut_error(span) { |
| // We've encountered a second (or more) attempt to mutably borrow an |
| // immutable binding, so the likely problem is with the binding |
| // declaration, not the use. We collect these in a single diagnostic |
| // and make the binding the primary span of the error. |
| err = buffered_err; |
| count = c + 1; |
| if count == 2 { |
| err.replace_span_with(span, false); |
| err.span_label(span, "not mutable"); |
| } |
| suggest = false; |
| } else { |
| err = self.cannot_borrow_path_as_mutable_because( |
| borrow_span, |
| &item_msg, |
| &reason, |
| ); |
| } |
| } |
| _ => { |
| err = self.cannot_borrow_path_as_mutable_because( |
| borrow_span, |
| &item_msg, |
| &reason, |
| ); |
| } |
| } |
| if suggest { |
| borrow_spans.var_subdiag( |
| self.dcx(), |
| &mut err, |
| Some(mir::BorrowKind::Mut { kind: mir::MutBorrowKind::Default }), |
| |_kind, var_span| { |
| let place = self.describe_any_place(access_place.as_ref()); |
| session_diagnostics::CaptureVarCause::MutableBorrowUsePlaceClosure { |
| place, |
| var_span, |
| } |
| }, |
| ); |
| } |
| borrow_span |
| } |
| }; |
| |
| debug!("report_mutability_error: act={:?}, acted_on={:?}", act, acted_on); |
| |
| match the_place_err { |
| // Suggest making an existing shared borrow in a struct definition a mutable borrow. |
| // |
| // This is applicable when we have a deref of a field access to a deref of a local - |
| // something like `*((*_1).0`. The local that we get will be a reference to the |
| // struct we've got a field access of (it must be a reference since there's a deref |
| // after the field access). |
| PlaceRef { |
| local, |
| projection: |
| [ |
| proj_base @ .., |
| ProjectionElem::Deref, |
| ProjectionElem::Field(field, _), |
| ProjectionElem::Deref, |
| ], |
| } => { |
| err.span_label(span, format!("cannot {act}")); |
| |
| let place = Place::ty_from(local, proj_base, self.body, self.infcx.tcx); |
| if let Some(span) = get_mut_span_in_struct_field(self.infcx.tcx, place.ty, *field) { |
| err.span_suggestion_verbose( |
| span, |
| "consider changing this to be mutable", |
| " mut ", |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } |
| |
| // Suggest removing a `&mut` from the use of a mutable reference. |
| PlaceRef { local, projection: [] } |
| if self |
| .body |
| .local_decls |
| .get(local) |
| .is_some_and(|l| mut_borrow_of_mutable_ref(l, self.local_names[local])) => |
| { |
| let decl = &self.body.local_decls[local]; |
| err.span_label(span, format!("cannot {act}")); |
| if let Some(mir::Statement { |
| source_info, |
| kind: |
| mir::StatementKind::Assign(box ( |
| _, |
| mir::Rvalue::Ref( |
| _, |
| mir::BorrowKind::Mut { kind: mir::MutBorrowKind::Default }, |
| _, |
| ), |
| )), |
| .. |
| }) = &self.body[location.block].statements.get(location.statement_index) |
| { |
| match *decl.local_info() { |
| LocalInfo::User(BindingForm::Var(mir::VarBindingForm { |
| binding_mode: BindingMode(ByRef::No, Mutability::Not), |
| opt_ty_info: Some(sp), |
| opt_match_place: _, |
| pat_span: _, |
| })) => { |
| if suggest { |
| err.span_note(sp, "the binding is already a mutable borrow"); |
| } |
| } |
| _ => { |
| err.span_note( |
| decl.source_info.span, |
| "the binding is already a mutable borrow", |
| ); |
| } |
| } |
| if let Ok(snippet) = |
| self.infcx.tcx.sess.source_map().span_to_snippet(source_info.span) |
| { |
| if snippet.starts_with("&mut ") { |
| // We don't have access to the HIR to get accurate spans, but we can |
| // give a best effort structured suggestion. |
| err.span_suggestion_verbose( |
| source_info.span.with_hi(source_info.span.lo() + BytePos(5)), |
| "try removing `&mut` here", |
| "", |
| Applicability::MachineApplicable, |
| ); |
| } else { |
| // This can occur with things like `(&mut self).foo()`. |
| err.span_help(source_info.span, "try removing `&mut` here"); |
| } |
| } else { |
| err.span_help(source_info.span, "try removing `&mut` here"); |
| } |
| } else if decl.mutability.is_not() { |
| if matches!( |
| decl.local_info(), |
| LocalInfo::User(BindingForm::ImplicitSelf(hir::ImplicitSelfKind::RefMut)) |
| ) { |
| err.note( |
| "as `Self` may be unsized, this call attempts to take `&mut &mut self`", |
| ); |
| err.note("however, `&mut self` expands to `self: &mut Self`, therefore `self` cannot be borrowed mutably"); |
| } else { |
| err.span_suggestion_verbose( |
| decl.source_info.span.shrink_to_lo(), |
| "consider making the binding mutable", |
| "mut ", |
| Applicability::MachineApplicable, |
| ); |
| }; |
| } |
| } |
| |
| // We want to suggest users use `let mut` for local (user |
| // variable) mutations... |
| PlaceRef { local, projection: [] } |
| if self.body.local_decls[local].can_be_made_mutable() => |
| { |
| // ... but it doesn't make sense to suggest it on |
| // variables that are `ref x`, `ref mut x`, `&self`, |
| // or `&mut self` (such variables are simply not |
| // mutable). |
| let local_decl = &self.body.local_decls[local]; |
| assert_eq!(local_decl.mutability, Mutability::Not); |
| |
| if count < 10 { |
| err.span_label(span, format!("cannot {act}")); |
| } |
| if suggest { |
| self.construct_mut_suggestion_for_local_binding_patterns(&mut err, local); |
| let tcx = self.infcx.tcx; |
| if let ty::Closure(id, _) = *the_place_err.ty(self.body, tcx).ty.kind() { |
| self.show_mutating_upvar(tcx, id.expect_local(), the_place_err, &mut err); |
| } |
| } |
| } |
| |
| // Also suggest adding mut for upvars |
| PlaceRef { |
| local, |
| projection: [proj_base @ .., ProjectionElem::Field(upvar_index, _)], |
| } => { |
| debug_assert!(is_closure_like( |
| Place::ty_from(local, proj_base, self.body, self.infcx.tcx).ty |
| )); |
| |
| let captured_place = self.upvars[upvar_index.index()]; |
| |
| err.span_label(span, format!("cannot {act}")); |
| |
| let upvar_hir_id = captured_place.get_root_variable(); |
| |
| if let Node::Pat(pat) = self.infcx.tcx.hir_node(upvar_hir_id) |
| && let hir::PatKind::Binding(hir::BindingMode::NONE, _, upvar_ident, _) = |
| pat.kind |
| { |
| if upvar_ident.name == kw::SelfLower { |
| for (_, node) in self.infcx.tcx.hir().parent_iter(upvar_hir_id) { |
| if let Some(fn_decl) = node.fn_decl() { |
| if !matches!( |
| fn_decl.implicit_self, |
| hir::ImplicitSelfKind::RefImm | hir::ImplicitSelfKind::RefMut |
| ) { |
| err.span_suggestion( |
| upvar_ident.span, |
| "consider changing this to be mutable", |
| format!("mut {}", upvar_ident.name), |
| Applicability::MachineApplicable, |
| ); |
| break; |
| } |
| } |
| } |
| } else { |
| err.span_suggestion( |
| upvar_ident.span, |
| "consider changing this to be mutable", |
| format!("mut {}", upvar_ident.name), |
| Applicability::MachineApplicable, |
| ); |
| } |
| } |
| |
| let tcx = self.infcx.tcx; |
| if let ty::Ref(_, ty, Mutability::Mut) = the_place_err.ty(self.body, tcx).ty.kind() |
| && let ty::Closure(id, _) = *ty.kind() |
| { |
| self.show_mutating_upvar(tcx, id.expect_local(), the_place_err, &mut err); |
| } |
| } |
| |
| // complete hack to approximate old AST-borrowck |
| // diagnostic: if the span starts with a mutable borrow of |
| // a local variable, then just suggest the user remove it. |
| PlaceRef { local: _, projection: [] } |
| if self |
| .infcx |
| .tcx |
| .sess |
| .source_map() |
| .span_to_snippet(span) |
| .is_ok_and(|snippet| snippet.starts_with("&mut ")) => |
| { |
| err.span_label(span, format!("cannot {act}")); |
| err.span_suggestion( |
| span, |
| "try removing `&mut` here", |
| "", |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| |
| PlaceRef { local, projection: [ProjectionElem::Deref] } |
| if self.body.local_decls[local].is_ref_for_guard() => |
| { |
| err.span_label(span, format!("cannot {act}")); |
| err.note( |
| "variables bound in patterns are immutable until the end of the pattern guard", |
| ); |
| } |
| |
| // We want to point out when a `&` can be readily replaced |
| // with an `&mut`. |
| // |
| // FIXME: can this case be generalized to work for an |
| // arbitrary base for the projection? |
| PlaceRef { local, projection: [ProjectionElem::Deref] } |
| if self.body.local_decls[local].is_user_variable() => |
| { |
| let local_decl = &self.body.local_decls[local]; |
| |
| let (pointer_sigil, pointer_desc) = |
| if local_decl.ty.is_ref() { ("&", "reference") } else { ("*const", "pointer") }; |
| |
| match self.local_names[local] { |
| Some(name) if !local_decl.from_compiler_desugaring() => { |
| err.span_label( |
| span, |
| format!( |
| "`{name}` is a `{pointer_sigil}` {pointer_desc}, \ |
| so the data it refers to cannot be {acted_on}", |
| ), |
| ); |
| |
| self.suggest_using_iter_mut(&mut err); |
| self.suggest_make_local_mut(&mut err, local, name); |
| } |
| _ => { |
| err.span_label( |
| span, |
| format!("cannot {act} through `{pointer_sigil}` {pointer_desc}"), |
| ); |
| } |
| } |
| } |
| |
| PlaceRef { local, projection: [ProjectionElem::Deref] } |
| if local == ty::CAPTURE_STRUCT_LOCAL && !self.upvars.is_empty() => |
| { |
| self.expected_fn_found_fn_mut_call(&mut err, span, act); |
| } |
| |
| PlaceRef { local: _, projection: [.., ProjectionElem::Deref] } => { |
| err.span_label(span, format!("cannot {act}")); |
| |
| match opt_source { |
| Some(BorrowedContentSource::OverloadedDeref(ty)) => { |
| err.help(format!( |
| "trait `DerefMut` is required to modify through a dereference, \ |
| but it is not implemented for `{ty}`", |
| )); |
| } |
| Some(BorrowedContentSource::OverloadedIndex(ty)) => { |
| err.help(format!( |
| "trait `IndexMut` is required to modify indexed content, \ |
| but it is not implemented for `{ty}`", |
| )); |
| self.suggest_map_index_mut_alternatives(ty, &mut err, span); |
| } |
| _ => (), |
| } |
| } |
| |
| _ => { |
| err.span_label(span, format!("cannot {act}")); |
| } |
| } |
| |
| if let Some(span) = mut_error { |
| self.buffer_mut_error(span, err, count); |
| } else { |
| self.buffer_error(err); |
| } |
| } |
| |
| /// Suggest `map[k] = v` => `map.insert(k, v)` and the like. |
| fn suggest_map_index_mut_alternatives(&self, ty: Ty<'tcx>, err: &mut Diag<'tcx>, span: Span) { |
| let Some(adt) = ty.ty_adt_def() else { return }; |
| let did = adt.did(); |
| if self.infcx.tcx.is_diagnostic_item(sym::HashMap, did) |
| || self.infcx.tcx.is_diagnostic_item(sym::BTreeMap, did) |
| { |
| /// Walks through the HIR, looking for the corresponding span for this error. |
| /// When it finds it, see if it corresponds to assignment operator whose LHS |
| /// is an index expr. |
| struct SuggestIndexOperatorAlternativeVisitor<'a, 'tcx> { |
| assign_span: Span, |
| err: &'a mut Diag<'tcx>, |
| ty: Ty<'tcx>, |
| suggested: bool, |
| } |
| impl<'a, 'tcx> Visitor<'tcx> for SuggestIndexOperatorAlternativeVisitor<'a, 'tcx> { |
| fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) { |
| hir::intravisit::walk_stmt(self, stmt); |
| let expr = match stmt.kind { |
| hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr) => expr, |
| hir::StmtKind::Let(hir::LetStmt { init: Some(expr), .. }) => expr, |
| _ => { |
| return; |
| } |
| }; |
| if let hir::ExprKind::Assign(place, rv, _sp) = expr.kind |
| && let hir::ExprKind::Index(val, index, _) = place.kind |
| && (expr.span == self.assign_span || place.span == self.assign_span) |
| { |
| // val[index] = rv; |
| // ---------- place |
| self.err.multipart_suggestions( |
| format!( |
| "to modify a `{}`, use `.get_mut()`, `.insert()` or the entry API", |
| self.ty, |
| ), |
| vec![ |
| vec![ |
| // val.insert(index, rv); |
| ( |
| val.span.shrink_to_hi().with_hi(index.span.lo()), |
| ".insert(".to_string(), |
| ), |
| ( |
| index.span.shrink_to_hi().with_hi(rv.span.lo()), |
| ", ".to_string(), |
| ), |
| (rv.span.shrink_to_hi(), ")".to_string()), |
| ], |
| vec![ |
| // val.get_mut(index).map(|v| { *v = rv; }); |
| ( |
| val.span.shrink_to_hi().with_hi(index.span.lo()), |
| ".get_mut(".to_string(), |
| ), |
| ( |
| index.span.shrink_to_hi().with_hi(place.span.hi()), |
| ").map(|val| { *val".to_string(), |
| ), |
| (rv.span.shrink_to_hi(), "; })".to_string()), |
| ], |
| vec![ |
| // let x = val.entry(index).or_insert(rv); |
| (val.span.shrink_to_lo(), "let val = ".to_string()), |
| ( |
| val.span.shrink_to_hi().with_hi(index.span.lo()), |
| ".entry(".to_string(), |
| ), |
| ( |
| index.span.shrink_to_hi().with_hi(rv.span.lo()), |
| ").or_insert(".to_string(), |
| ), |
| (rv.span.shrink_to_hi(), ")".to_string()), |
| ], |
| ], |
| Applicability::MachineApplicable, |
| ); |
| self.suggested = true; |
| } else if let hir::ExprKind::MethodCall(_path, receiver, _, sp) = expr.kind |
| && let hir::ExprKind::Index(val, index, _) = receiver.kind |
| && expr.span == self.assign_span |
| { |
| // val[index].path(args..); |
| self.err.multipart_suggestion( |
| format!("to modify a `{}` use `.get_mut()`", self.ty), |
| vec![ |
| ( |
| val.span.shrink_to_hi().with_hi(index.span.lo()), |
| ".get_mut(".to_string(), |
| ), |
| ( |
| index.span.shrink_to_hi().with_hi(receiver.span.hi()), |
| ").map(|val| val".to_string(), |
| ), |
| (sp.shrink_to_hi(), ")".to_string()), |
| ], |
| Applicability::MachineApplicable, |
| ); |
| self.suggested = true; |
| } |
| } |
| } |
| let hir_map = self.infcx.tcx.hir(); |
| let def_id = self.body.source.def_id(); |
| let Some(local_def_id) = def_id.as_local() else { return }; |
| let Some(body_id) = hir_map.maybe_body_owned_by(local_def_id) else { return }; |
| let body = self.infcx.tcx.hir().body(body_id); |
| |
| let mut v = SuggestIndexOperatorAlternativeVisitor { |
| assign_span: span, |
| err, |
| ty, |
| suggested: false, |
| }; |
| v.visit_body(body); |
| if !v.suggested { |
| err.help(format!( |
| "to modify a `{ty}`, use `.get_mut()`, `.insert()` or the entry API", |
| )); |
| } |
| } |
| } |
| |
| /// User cannot make signature of a trait mutable without changing the |
| /// trait. So we find if this error belongs to a trait and if so we move |
| /// suggestion to the trait or disable it if it is out of scope of this crate |
| /// |
| /// The returned values are: |
| /// - is the current item an assoc `fn` of an impl that corresponds to a trait def? if so, we |
| /// have to suggest changing both the impl `fn` arg and the trait `fn` arg |
| /// - is the trait from the local crate? If not, we can't suggest changing signatures |
| /// - `Span` of the argument in the trait definition |
| fn is_error_in_trait(&self, local: Local) -> (bool, bool, Option<Span>) { |
| if self.body.local_kind(local) != LocalKind::Arg { |
| return (false, false, None); |
| } |
| let my_def = self.body.source.def_id(); |
| let my_hir = self.infcx.tcx.local_def_id_to_hir_id(my_def.as_local().unwrap()); |
| let Some(td) = |
| self.infcx.tcx.impl_of_method(my_def).and_then(|x| self.infcx.tcx.trait_id_of_impl(x)) |
| else { |
| return (false, false, None); |
| }; |
| ( |
| true, |
| td.is_local(), |
| td.as_local().and_then(|tld| match self.infcx.tcx.hir_node_by_def_id(tld) { |
| Node::Item(hir::Item { kind: hir::ItemKind::Trait(_, _, _, _, items), .. }) => { |
| let mut f_in_trait_opt = None; |
| for hir::TraitItemRef { id: fi, kind: k, .. } in *items { |
| let hi = fi.hir_id(); |
| if !matches!(k, hir::AssocItemKind::Fn { .. }) { |
| continue; |
| } |
| if self.infcx.tcx.hir().name(hi) != self.infcx.tcx.hir().name(my_hir) { |
| continue; |
| } |
| f_in_trait_opt = Some(hi); |
| break; |
| } |
| f_in_trait_opt.and_then(|f_in_trait| { |
| if let Node::TraitItem(ti) = self.infcx.tcx.hir_node(f_in_trait) |
| && let hir::TraitItemKind::Fn(sig, _) = ti.kind |
| && let Some(ty) = sig.decl.inputs.get(local.index() - 1) |
| && let hir::TyKind::Ref(_, mut_ty) = ty.kind |
| && let hir::Mutability::Not = mut_ty.mutbl |
| && sig.decl.implicit_self.has_implicit_self() |
| { |
| Some(ty.span) |
| } else { |
| None |
| } |
| }) |
| } |
| _ => None, |
| }), |
| ) |
| } |
| |
| fn construct_mut_suggestion_for_local_binding_patterns( |
| &self, |
| err: &mut Diag<'_>, |
| local: Local, |
| ) { |
| let local_decl = &self.body.local_decls[local]; |
| debug!("local_decl: {:?}", local_decl); |
| let pat_span = match *local_decl.local_info() { |
| LocalInfo::User(BindingForm::Var(mir::VarBindingForm { |
| binding_mode: BindingMode(ByRef::No, Mutability::Not), |
| opt_ty_info: _, |
| opt_match_place: _, |
| pat_span, |
| })) => pat_span, |
| _ => local_decl.source_info.span, |
| }; |
| |
| // With ref-binding patterns, the mutability suggestion has to apply to |
| // the binding, not the reference (which would be a type error): |
| // |
| // `let &b = a;` -> `let &(mut b) = a;` |
| // or |
| // `fn foo(&x: &i32)` -> `fn foo(&(mut x): &i32)` |
| let def_id = self.body.source.def_id(); |
| if let Some(local_def_id) = def_id.as_local() |
| && let Some(body_id) = self.infcx.tcx.hir().maybe_body_owned_by(local_def_id) |
| && let body = self.infcx.tcx.hir().body(body_id) |
| && let Some(hir_id) = (BindingFinder { span: pat_span }).visit_body(body).break_value() |
| && let node = self.infcx.tcx.hir_node(hir_id) |
| && let hir::Node::LetStmt(hir::LetStmt { |
| pat: hir::Pat { kind: hir::PatKind::Ref(_, _), .. }, |
| .. |
| }) |
| | hir::Node::Param(Param { |
| pat: hir::Pat { kind: hir::PatKind::Ref(_, _), .. }, |
| .. |
| }) = node |
| && let Ok(name) = |
| self.infcx.tcx.sess.source_map().span_to_snippet(local_decl.source_info.span) |
| { |
| err.span_suggestion( |
| pat_span, |
| "consider changing this to be mutable", |
| format!("&(mut {name})"), |
| Applicability::MachineApplicable, |
| ); |
| return; |
| } |
| |
| err.span_suggestion_verbose( |
| local_decl.source_info.span.shrink_to_lo(), |
| "consider changing this to be mutable", |
| "mut ", |
| Applicability::MachineApplicable, |
| ); |
| } |
| |
| // point to span of upvar making closure call require mutable borrow |
| fn show_mutating_upvar( |
| &self, |
| tcx: TyCtxt<'_>, |
| closure_local_def_id: hir::def_id::LocalDefId, |
| the_place_err: PlaceRef<'tcx>, |
| err: &mut Diag<'_>, |
| ) { |
| let tables = tcx.typeck(closure_local_def_id); |
| if let Some((span, closure_kind_origin)) = tcx.closure_kind_origin(closure_local_def_id) { |
| let reason = if let PlaceBase::Upvar(upvar_id) = closure_kind_origin.base { |
| let upvar = ty::place_to_string_for_capture(tcx, closure_kind_origin); |
| let root_hir_id = upvar_id.var_path.hir_id; |
| // we have an origin for this closure kind starting at this root variable so it's safe to unwrap here |
| let captured_places = |
| tables.closure_min_captures[&closure_local_def_id].get(&root_hir_id).unwrap(); |
| |
| let origin_projection = closure_kind_origin |
| .projections |
| .iter() |
| .map(|proj| proj.kind) |
| .collect::<Vec<_>>(); |
| let mut capture_reason = String::new(); |
| for captured_place in captured_places { |
| let captured_place_kinds = captured_place |
| .place |
| .projections |
| .iter() |
| .map(|proj| proj.kind) |
| .collect::<Vec<_>>(); |
| if rustc_middle::ty::is_ancestor_or_same_capture( |
| &captured_place_kinds, |
| &origin_projection, |
| ) { |
| match captured_place.info.capture_kind { |
| ty::UpvarCapture::ByRef( |
| ty::BorrowKind::MutBorrow | ty::BorrowKind::UniqueImmBorrow, |
| ) => { |
| capture_reason = format!("mutable borrow of `{upvar}`"); |
| } |
| ty::UpvarCapture::ByValue => { |
| capture_reason = format!("possible mutation of `{upvar}`"); |
| } |
| _ => bug!("upvar `{upvar}` borrowed, but not mutably"), |
| } |
| break; |
| } |
| } |
| if capture_reason.is_empty() { |
| bug!("upvar `{upvar}` borrowed, but cannot find reason"); |
| } |
| capture_reason |
| } else { |
| bug!("not an upvar") |
| }; |
| err.span_label( |
| *span, |
| format!( |
| "calling `{}` requires mutable binding due to {}", |
| self.describe_place(the_place_err).unwrap(), |
| reason |
| ), |
| ); |
| } |
| } |
| |
| // Attempt to search similar mutable associated items for suggestion. |
| // In the future, attempt in all path but initially for RHS of for_loop |
| fn suggest_similar_mut_method_for_for_loop(&self, err: &mut Diag<'_>, span: Span) { |
| use hir::{ |
| BorrowKind, Expr, |
| ExprKind::{AddrOf, Block, Call, MethodCall}, |
| }; |
| |
| let hir_map = self.infcx.tcx.hir(); |
| struct Finder { |
| span: Span, |
| } |
| |
| impl<'tcx> Visitor<'tcx> for Finder { |
| type Result = ControlFlow<&'tcx Expr<'tcx>>; |
| fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) -> Self::Result { |
| if e.span == self.span { |
| ControlFlow::Break(e) |
| } else { |
| hir::intravisit::walk_expr(self, e) |
| } |
| } |
| } |
| if let Some(body_id) = hir_map.maybe_body_owned_by(self.mir_def_id()) |
| && let Block(block, _) = hir_map.body(body_id).value.kind |
| { |
| // `span` corresponds to the expression being iterated, find the `for`-loop desugared |
| // expression with that span in order to identify potential fixes when encountering a |
| // read-only iterator that should be mutable. |
| if let ControlFlow::Break(expr) = (Finder { span }).visit_block(block) |
| && let Call(_, [expr]) = expr.kind |
| { |
| match expr.kind { |
| MethodCall(path_segment, _, _, span) => { |
| // We have `for _ in iter.read_only_iter()`, try to |
| // suggest `for _ in iter.mutable_iter()` instead. |
| let opt_suggestions = self |
| .infcx |
| .tcx |
| .typeck(path_segment.hir_id.owner.def_id) |
| .type_dependent_def_id(expr.hir_id) |
| .and_then(|def_id| self.infcx.tcx.impl_of_method(def_id)) |
| .map(|def_id| self.infcx.tcx.associated_items(def_id)) |
| .map(|assoc_items| { |
| assoc_items |
| .in_definition_order() |
| .map(|assoc_item_def| assoc_item_def.ident(self.infcx.tcx)) |
| .filter(|&ident| { |
| let original_method_ident = path_segment.ident; |
| original_method_ident != ident |
| && ident.as_str().starts_with( |
| &original_method_ident.name.to_string(), |
| ) |
| }) |
| .map(|ident| format!("{ident}()")) |
| .peekable() |
| }); |
| |
| if let Some(mut suggestions) = opt_suggestions |
| && suggestions.peek().is_some() |
| { |
| err.span_suggestions( |
| span, |
| "use mutable method", |
| suggestions, |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } |
| AddrOf(BorrowKind::Ref, Mutability::Not, expr) => { |
| // We have `for _ in &i`, suggest `for _ in &mut i`. |
| err.span_suggestion_verbose( |
| expr.span.shrink_to_lo(), |
| "use a mutable iterator instead", |
| "mut ", |
| Applicability::MachineApplicable, |
| ); |
| } |
| _ => {} |
| } |
| } |
| } |
| } |
| |
| /// Targeted error when encountering an `FnMut` closure where an `Fn` closure was expected. |
| fn expected_fn_found_fn_mut_call(&self, err: &mut Diag<'_>, sp: Span, act: &str) { |
| err.span_label(sp, format!("cannot {act}")); |
| |
| let hir = self.infcx.tcx.hir(); |
| let closure_id = self.mir_hir_id(); |
| let closure_span = self.infcx.tcx.def_span(self.mir_def_id()); |
| let fn_call_id = self.infcx.tcx.parent_hir_id(closure_id); |
| let node = self.infcx.tcx.hir_node(fn_call_id); |
| let def_id = hir.enclosing_body_owner(fn_call_id); |
| let mut look_at_return = true; |
| // If we can detect the expression to be an `fn` call where the closure was an argument, |
| // we point at the `fn` definition argument... |
| if let hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Call(func, args), .. }) = node { |
| let arg_pos = args |
| .iter() |
| .enumerate() |
| .filter(|(_, arg)| arg.hir_id == closure_id) |
| .map(|(pos, _)| pos) |
| .next(); |
| let tables = self.infcx.tcx.typeck(def_id); |
| if let Some(ty::FnDef(def_id, _)) = |
| tables.node_type_opt(func.hir_id).as_ref().map(|ty| ty.kind()) |
| { |
| let arg = match hir.get_if_local(*def_id) { |
| Some( |
| hir::Node::Item(hir::Item { |
| ident, kind: hir::ItemKind::Fn(sig, ..), .. |
| }) |
| | hir::Node::TraitItem(hir::TraitItem { |
| ident, |
| kind: hir::TraitItemKind::Fn(sig, _), |
| .. |
| }) |
| | hir::Node::ImplItem(hir::ImplItem { |
| ident, |
| kind: hir::ImplItemKind::Fn(sig, _), |
| .. |
| }), |
| ) => Some( |
| arg_pos |
| .and_then(|pos| { |
| sig.decl.inputs.get( |
| pos + if sig.decl.implicit_self.has_implicit_self() { |
| 1 |
| } else { |
| 0 |
| }, |
| ) |
| }) |
| .map(|arg| arg.span) |
| .unwrap_or(ident.span), |
| ), |
| _ => None, |
| }; |
| if let Some(span) = arg { |
| err.span_label(span, "change this to accept `FnMut` instead of `Fn`"); |
| err.span_label(func.span, "expects `Fn` instead of `FnMut`"); |
| err.span_label(closure_span, "in this closure"); |
| look_at_return = false; |
| } |
| } |
| } |
| |
| if look_at_return && hir.get_return_block(closure_id).is_some() { |
| // ...otherwise we are probably in the tail expression of the function, point at the |
| // return type. |
| match self.infcx.tcx.hir_node_by_def_id(hir.get_parent_item(fn_call_id).def_id) { |
| hir::Node::Item(hir::Item { ident, kind: hir::ItemKind::Fn(sig, ..), .. }) |
| | hir::Node::TraitItem(hir::TraitItem { |
| ident, |
| kind: hir::TraitItemKind::Fn(sig, _), |
| .. |
| }) |
| | hir::Node::ImplItem(hir::ImplItem { |
| ident, |
| kind: hir::ImplItemKind::Fn(sig, _), |
| .. |
| }) => { |
| err.span_label(ident.span, ""); |
| err.span_label( |
| sig.decl.output.span(), |
| "change this to return `FnMut` instead of `Fn`", |
| ); |
| err.span_label(closure_span, "in this closure"); |
| } |
| _ => {} |
| } |
| } |
| } |
| |
| fn suggest_using_iter_mut(&self, err: &mut Diag<'_>) { |
| let source = self.body.source; |
| let hir = self.infcx.tcx.hir(); |
| if let InstanceDef::Item(def_id) = source.instance |
| && let Some(Node::Expr(hir::Expr { hir_id, kind, .. })) = hir.get_if_local(def_id) |
| && let ExprKind::Closure(hir::Closure { kind: hir::ClosureKind::Closure, .. }) = kind |
| && let Node::Expr(expr) = self.infcx.tcx.parent_hir_node(*hir_id) |
| { |
| let mut cur_expr = expr; |
| while let ExprKind::MethodCall(path_segment, recv, _, _) = cur_expr.kind { |
| if path_segment.ident.name == sym::iter { |
| // check `_ty` has `iter_mut` method |
| let res = self |
| .infcx |
| .tcx |
| .typeck(path_segment.hir_id.owner.def_id) |
| .type_dependent_def_id(cur_expr.hir_id) |
| .and_then(|def_id| self.infcx.tcx.impl_of_method(def_id)) |
| .map(|def_id| self.infcx.tcx.associated_items(def_id)) |
| .map(|assoc_items| { |
| assoc_items.filter_by_name_unhygienic(sym::iter_mut).peekable() |
| }); |
| |
| if let Some(mut res) = res |
| && res.peek().is_some() |
| { |
| err.span_suggestion_verbose( |
| path_segment.ident.span, |
| "you may want to use `iter_mut` here", |
| "iter_mut", |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| break; |
| } else { |
| cur_expr = recv; |
| } |
| } |
| } |
| } |
| |
| fn suggest_make_local_mut(&self, err: &mut Diag<'_>, local: Local, name: Symbol) { |
| let local_decl = &self.body.local_decls[local]; |
| |
| let (pointer_sigil, pointer_desc) = |
| if local_decl.ty.is_ref() { ("&", "reference") } else { ("*const", "pointer") }; |
| |
| let (is_trait_sig, is_local, local_trait) = self.is_error_in_trait(local); |
| |
| if is_trait_sig && !is_local { |
| // Do not suggest to change the signature when the trait comes from another crate. |
| err.span_label( |
| local_decl.source_info.span, |
| format!("this is an immutable {pointer_desc}"), |
| ); |
| return; |
| } |
| let decl_span = local_decl.source_info.span; |
| |
| let label = match *local_decl.local_info() { |
| LocalInfo::User(mir::BindingForm::ImplicitSelf(_)) => { |
| let suggestion = suggest_ampmut_self(self.infcx.tcx, decl_span); |
| let additional = |
| local_trait.map(|span| (span, suggest_ampmut_self(self.infcx.tcx, span))); |
| Some((true, decl_span, suggestion, additional)) |
| } |
| |
| LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm { |
| binding_mode: BindingMode(ByRef::No, _), |
| opt_ty_info, |
| .. |
| })) => { |
| // check if the RHS is from desugaring |
| let opt_assignment_rhs_span = |
| self.body.find_assignments(local).first().map(|&location| { |
| if let Some(mir::Statement { |
| source_info: _, |
| kind: |
| mir::StatementKind::Assign(box ( |
| _, |
| mir::Rvalue::Use(mir::Operand::Copy(place)), |
| )), |
| }) = self.body[location.block].statements.get(location.statement_index) |
| { |
| self.body.local_decls[place.local].source_info.span |
| } else { |
| self.body.source_info(location).span |
| } |
| }); |
| match opt_assignment_rhs_span.and_then(|s| s.desugaring_kind()) { |
| // on for loops, RHS points to the iterator part |
| Some(DesugaringKind::ForLoop) => { |
| let span = opt_assignment_rhs_span.unwrap(); |
| self.suggest_similar_mut_method_for_for_loop(err, span); |
| err.span_label( |
| span, |
| format!("this iterator yields `{pointer_sigil}` {pointer_desc}s",), |
| ); |
| None |
| } |
| // don't create labels for compiler-generated spans |
| Some(_) => None, |
| None => { |
| let (has_sugg, decl_span, sugg) = if name != kw::SelfLower { |
| suggest_ampmut( |
| self.infcx.tcx, |
| local_decl.ty, |
| decl_span, |
| opt_assignment_rhs_span, |
| opt_ty_info, |
| ) |
| } else { |
| match local_decl.local_info() { |
| LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm { |
| opt_ty_info: None, |
| .. |
| })) => { |
| let sugg = suggest_ampmut_self(self.infcx.tcx, decl_span); |
| (true, decl_span, sugg) |
| } |
| // explicit self (eg `self: &'a Self`) |
| _ => suggest_ampmut( |
| self.infcx.tcx, |
| local_decl.ty, |
| decl_span, |
| opt_assignment_rhs_span, |
| opt_ty_info, |
| ), |
| } |
| }; |
| Some((has_sugg, decl_span, sugg, None)) |
| } |
| } |
| } |
| |
| LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm { |
| binding_mode: BindingMode(ByRef::Yes(_), _), |
| .. |
| })) => { |
| let pattern_span: Span = local_decl.source_info.span; |
| suggest_ref_mut(self.infcx.tcx, pattern_span) |
| .map(|span| (true, span, "mut ".to_owned(), None)) |
| } |
| |
| _ => unreachable!(), |
| }; |
| |
| match label { |
| Some((true, err_help_span, suggested_code, additional)) => { |
| let mut sugg = vec![(err_help_span, suggested_code)]; |
| if let Some(s) = additional { |
| sugg.push(s); |
| } |
| |
| err.multipart_suggestion_verbose( |
| format!( |
| "consider changing this to be a mutable {pointer_desc}{}", |
| if is_trait_sig { |
| " in the `impl` method and the `trait` definition" |
| } else { |
| "" |
| } |
| ), |
| sugg, |
| Applicability::MachineApplicable, |
| ); |
| } |
| Some((false, err_label_span, message, _)) => { |
| let def_id = self.body.source.def_id(); |
| let hir_id = if let Some(local_def_id) = def_id.as_local() |
| && let Some(body_id) = self.infcx.tcx.hir().maybe_body_owned_by(local_def_id) |
| { |
| let body = self.infcx.tcx.hir().body(body_id); |
| BindingFinder { span: err_label_span }.visit_body(body).break_value() |
| } else { |
| None |
| }; |
| |
| if let Some(hir_id) = hir_id |
| && let hir::Node::LetStmt(local) = self.infcx.tcx.hir_node(hir_id) |
| { |
| let tables = self.infcx.tcx.typeck(def_id.as_local().unwrap()); |
| if let Some(clone_trait) = self.infcx.tcx.lang_items().clone_trait() |
| && let Some(expr) = local.init |
| && let ty = tables.node_type_opt(expr.hir_id) |
| && let Some(ty) = ty |
| && let ty::Ref(..) = ty.kind() |
| { |
| match self |
| .infcx |
| .type_implements_trait_shallow( |
| clone_trait, |
| ty.peel_refs(), |
| self.param_env, |
| ) |
| .as_deref() |
| { |
| Some([]) => { |
| // FIXME: This error message isn't useful, since we're just |
| // vaguely suggesting to clone a value that already |
| // implements `Clone`. |
| // |
| // A correct suggestion here would take into account the fact |
| // that inference may be affected by missing types on bindings, |
| // etc., to improve "tests/ui/borrowck/issue-91206.stderr", for |
| // example. |
| } |
| None => { |
| if let hir::ExprKind::MethodCall(segment, _rcvr, [], span) = |
| expr.kind |
| && segment.ident.name == sym::clone |
| { |
| err.span_help( |
| span, |
| format!( |
| "`{}` doesn't implement `Clone`, so this call clones \ |
| the reference `{ty}`", |
| ty.peel_refs(), |
| ), |
| ); |
| } |
| // The type doesn't implement Clone. |
| let trait_ref = ty::Binder::dummy(ty::TraitRef::new( |
| self.infcx.tcx, |
| clone_trait, |
| [ty.peel_refs()], |
| )); |
| let obligation = traits::Obligation::new( |
| self.infcx.tcx, |
| traits::ObligationCause::dummy(), |
| self.param_env, |
| trait_ref, |
| ); |
| self.infcx.err_ctxt().suggest_derive( |
| &obligation, |
| err, |
| trait_ref.to_predicate(self.infcx.tcx), |
| ); |
| } |
| Some(errors) => { |
| if let hir::ExprKind::MethodCall(segment, _rcvr, [], span) = |
| expr.kind |
| && segment.ident.name == sym::clone |
| { |
| err.span_help( |
| span, |
| format!( |
| "`{}` doesn't implement `Clone` because its \ |
| implementations trait bounds could not be met, so \ |
| this call clones the reference `{ty}`", |
| ty.peel_refs(), |
| ), |
| ); |
| err.note(format!( |
| "the following trait bounds weren't met: {}", |
| errors |
| .iter() |
| .map(|e| e.obligation.predicate.to_string()) |
| .collect::<Vec<_>>() |
| .join("\n"), |
| )); |
| } |
| // The type doesn't implement Clone because of unmet obligations. |
| for error in errors { |
| if let traits::FulfillmentErrorCode::Select( |
| traits::SelectionError::Unimplemented, |
| ) = error.code |
| && let ty::PredicateKind::Clause(ty::ClauseKind::Trait( |
| pred, |
| )) = error.obligation.predicate.kind().skip_binder() |
| { |
| self.infcx.err_ctxt().suggest_derive( |
| &error.obligation, |
| err, |
| error.obligation.predicate.kind().rebind(pred), |
| ); |
| } |
| } |
| } |
| } |
| } |
| let (changing, span, sugg) = match local.ty { |
| Some(ty) => ("changing", ty.span, message), |
| None => { |
| ("specifying", local.pat.span.shrink_to_hi(), format!(": {message}")) |
| } |
| }; |
| err.span_suggestion_verbose( |
| span, |
| format!("consider {changing} this binding's type"), |
| sugg, |
| Applicability::HasPlaceholders, |
| ); |
| } else { |
| err.span_label( |
| err_label_span, |
| format!("consider changing this binding's type to be: `{message}`"), |
| ); |
| } |
| } |
| None => {} |
| } |
| } |
| } |
| |
| struct BindingFinder { |
| span: Span, |
| } |
| |
| impl<'tcx> Visitor<'tcx> for BindingFinder { |
| type Result = ControlFlow<hir::HirId>; |
| fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) -> Self::Result { |
| if let hir::StmtKind::Let(local) = s.kind |
| && local.pat.span == self.span |
| { |
| ControlFlow::Break(local.hir_id) |
| } else { |
| hir::intravisit::walk_stmt(self, s) |
| } |
| } |
| |
| fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) -> Self::Result { |
| if let hir::Pat { kind: hir::PatKind::Ref(_, _), span, .. } = param.pat |
| && *span == self.span |
| { |
| ControlFlow::Break(param.hir_id) |
| } else { |
| ControlFlow::Continue(()) |
| } |
| } |
| } |
| |
| pub fn mut_borrow_of_mutable_ref(local_decl: &LocalDecl<'_>, local_name: Option<Symbol>) -> bool { |
| debug!("local_info: {:?}, ty.kind(): {:?}", local_decl.local_info, local_decl.ty.kind()); |
| |
| match *local_decl.local_info() { |
| // Check if mutably borrowing a mutable reference. |
| LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm { |
| binding_mode: BindingMode(ByRef::No, Mutability::Not), |
| .. |
| })) => matches!(local_decl.ty.kind(), ty::Ref(_, _, hir::Mutability::Mut)), |
| LocalInfo::User(mir::BindingForm::ImplicitSelf(kind)) => { |
| // Check if the user variable is a `&mut self` and we can therefore |
| // suggest removing the `&mut`. |
| // |
| // Deliberately fall into this case for all implicit self types, |
| // so that we don't fall into the next case with them. |
| kind == hir::ImplicitSelfKind::RefMut |
| } |
| _ if Some(kw::SelfLower) == local_name => { |
| // Otherwise, check if the name is the `self` keyword - in which case |
| // we have an explicit self. Do the same thing in this case and check |
| // for a `self: &mut Self` to suggest removing the `&mut`. |
| matches!(local_decl.ty.kind(), ty::Ref(_, _, hir::Mutability::Mut)) |
| } |
| _ => false, |
| } |
| } |
| |
| fn suggest_ampmut_self<'tcx>(tcx: TyCtxt<'tcx>, span: Span) -> String { |
| match tcx.sess.source_map().span_to_snippet(span) { |
| Ok(snippet) => { |
| let lt_pos = snippet.find('\''); |
| if let Some(lt_pos) = lt_pos { |
| format!("&{}mut self", &snippet[lt_pos..snippet.len() - 4]) |
| } else { |
| "&mut self".to_string() |
| } |
| } |
| _ => "&mut self".to_string(), |
| } |
| } |
| |
| // When we want to suggest a user change a local variable to be a `&mut`, there |
| // are three potential "obvious" things to highlight: |
| // |
| // let ident [: Type] [= RightHandSideExpression]; |
| // ^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ |
| // (1.) (2.) (3.) |
| // |
| // We can always fallback on highlighting the first. But chances are good that |
| // the user experience will be better if we highlight one of the others if possible; |
| // for example, if the RHS is present and the Type is not, then the type is going to |
| // be inferred *from* the RHS, which means we should highlight that (and suggest |
| // that they borrow the RHS mutably). |
| // |
| // This implementation attempts to emulate AST-borrowck prioritization |
| // by trying (3.), then (2.) and finally falling back on (1.). |
| fn suggest_ampmut<'tcx>( |
| tcx: TyCtxt<'tcx>, |
| decl_ty: Ty<'tcx>, |
| decl_span: Span, |
| opt_assignment_rhs_span: Option<Span>, |
| opt_ty_info: Option<Span>, |
| ) -> (bool, Span, String) { |
| // if there is a RHS and it starts with a `&` from it, then check if it is |
| // mutable, and if not, put suggest putting `mut ` to make it mutable. |
| // we don't have to worry about lifetime annotations here because they are |
| // not valid when taking a reference. For example, the following is not valid Rust: |
| // |
| // let x: &i32 = &'a 5; |
| // ^^ lifetime annotation not allowed |
| // |
| if let Some(assignment_rhs_span) = opt_assignment_rhs_span |
| && let Ok(src) = tcx.sess.source_map().span_to_snippet(assignment_rhs_span) |
| && let Some(stripped) = src.strip_prefix('&') |
| { |
| let is_mut = if let Some(rest) = stripped.trim_start().strip_prefix("mut") { |
| match rest.chars().next() { |
| // e.g. `&mut x` |
| Some(c) if c.is_whitespace() => true, |
| // e.g. `&mut(x)` |
| Some('(') => true, |
| // e.g. `&mut{x}` |
| Some('{') => true, |
| // e.g. `&mutablevar` |
| _ => false, |
| } |
| } else { |
| false |
| }; |
| // if the reference is already mutable then there is nothing we can do |
| // here. |
| if !is_mut { |
| let span = assignment_rhs_span; |
| // shrink the span to just after the `&` in `&variable` |
| let span = span.with_lo(span.lo() + BytePos(1)).shrink_to_lo(); |
| |
| // FIXME(Ezrashaw): returning is bad because we still might want to |
| // update the annotated type, see #106857. |
| return (true, span, "mut ".to_owned()); |
| } |
| } |
| |
| let (binding_exists, span) = match opt_ty_info { |
| // if this is a variable binding with an explicit type, |
| // then we will suggest changing it to be mutable. |
| // this is `Applicability::MachineApplicable`. |
| Some(ty_span) => (true, ty_span), |
| |
| // otherwise, we'll suggest *adding* an annotated type, we'll suggest |
| // the RHS's type for that. |
| // this is `Applicability::HasPlaceholders`. |
| None => (false, decl_span), |
| }; |
| |
| // if the binding already exists and is a reference with an explicit |
| // lifetime, then we can suggest adding ` mut`. this is special-cased from |
| // the path without an explicit lifetime. |
| if let Ok(src) = tcx.sess.source_map().span_to_snippet(span) |
| && src.starts_with("&'") |
| // note that `& 'a T` is invalid so this is correct. |
| && let Some(ws_pos) = src.find(char::is_whitespace) |
| { |
| let span = span.with_lo(span.lo() + BytePos(ws_pos as u32)).shrink_to_lo(); |
| (true, span, " mut".to_owned()) |
| // if there is already a binding, we modify it to be `mut` |
| } else if binding_exists { |
| // shrink the span to just after the `&` in `&variable` |
| let span = span.with_lo(span.lo() + BytePos(1)).shrink_to_lo(); |
| (true, span, "mut ".to_owned()) |
| } else { |
| // otherwise, suggest that the user annotates the binding; we provide the |
| // type of the local. |
| let ty = decl_ty.builtin_deref(true).unwrap(); |
| |
| (false, span, format!("{}mut {}", if decl_ty.is_ref() { "&" } else { "*" }, ty)) |
| } |
| } |
| |
| /// If the type is a `Coroutine`, `Closure`, or `CoroutineClosure` |
| fn is_closure_like(ty: Ty<'_>) -> bool { |
| ty.is_closure() || ty.is_coroutine() || ty.is_coroutine_closure() |
| } |
| |
| /// Given a field that needs to be mutable, returns a span where the " mut " could go. |
| /// This function expects the local to be a reference to a struct in order to produce a span. |
| /// |
| /// ```text |
| /// LL | s: &'a String |
| /// | ^^^ returns a span taking up the space here |
| /// ``` |
| fn get_mut_span_in_struct_field<'tcx>( |
| tcx: TyCtxt<'tcx>, |
| ty: Ty<'tcx>, |
| field: FieldIdx, |
| ) -> Option<Span> { |
| // Expect our local to be a reference to a struct of some kind. |
| if let ty::Ref(_, ty, _) = ty.kind() |
| && let ty::Adt(def, _) = ty.kind() |
| && let field = def.all_fields().nth(field.index())? |
| // Now we're dealing with the actual struct that we're going to suggest a change to, |
| // we can expect a field that is an immutable reference to a type. |
| && let hir::Node::Field(field) = tcx.hir_node_by_def_id(field.did.as_local()?) |
| && let hir::TyKind::Ref(lt, hir::MutTy { mutbl: hir::Mutability::Not, ty }) = field.ty.kind |
| { |
| return Some(lt.ident.span.between(ty.span)); |
| } |
| |
| None |
| } |
| |
| /// If possible, suggest replacing `ref` with `ref mut`. |
| fn suggest_ref_mut(tcx: TyCtxt<'_>, span: Span) -> Option<Span> { |
| let pattern_str = tcx.sess.source_map().span_to_snippet(span).ok()?; |
| if pattern_str.starts_with("ref") |
| && pattern_str["ref".len()..].starts_with(rustc_lexer::is_whitespace) |
| { |
| let span = span.with_lo(span.lo() + BytePos(4)).shrink_to_lo(); |
| Some(span) |
| } else { |
| None |
| } |
| } |
