Rust should explain why a closure call requires a mutable borrow

[Aaron1011]

The following code:

fn main() {
    let mut my_var = false;
    let callback = || {
        my_var = true;
    };
    callback();
}

produces the following error:

error[E0596]: cannot borrow `callback` as mutable, as it is not declared as mutable
 --> src/main.rs:6:5
  |
3 |     let callback = || {
  |         -------- help: consider changing this to be mutable: `mut callback`
...
6 |     callback();
  |     ^^^^^^^^ cannot borrow as mutable

error: aborting due to previous error

The expression callback() tries to mutably borrow callback due to the mutation of my_var. However, the error message doesn't explain this.

We should add a note to the error message pointing to the span of the upvar that caused us to need the mutable borrow.

[camelid]

So it looks like this is the function that needs to be modified:

rust/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs

Lines 23 to 30 in 89886e6

	pub(crate) fn report_mutability_error(
	&mut self,
	access_place: Place<'tcx>,
	span: Span,
	the_place_err: PlaceRef<'tcx>,
	error_access: AccessKind,
	location: Location,
	) {

It seems I might be able to get the information I need from self.used_mut_upvars?

[camelid]

Actually, self.used_mut_upvars won't work here because it's only used when we're borrow-checking the closure, not uses of it (self.used_mut_upvars is empty in this context).

[sledgehammervampire]

@rustbot claim

[sledgehammervampire]

Is anyone going to work on this issue? If not, I want to work on this to help me learn how Rust works.

[Aaron1011]

@1000teslas Go ahead! If you need any help, feel free to reach out to me on Zulip or Discord

[camelid]

I was working on this, but I guess I should have pinged Aaron: https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/finding.20mutated.20upvars.20in.20borrowck. Oh well :)

@1000teslas you can work on this, I have other things that I've been meaning to get to anyway.

[sledgehammervampire]

@Aaron1011 What is the intended error? Is it meant to point to my_var, similarly to room_ref in #78938?

[Aaron1011]

Yes - I was thinking of displaying a message like "a mutable borrow is required because the closure modifies my_var", located at the usage of my_var. Additionally, we could add another note pointing to the definition of my_var.

[sledgehammervampire]

I'm not sure how given a Location or Place of a call, we can obtain the Local pointing to the definition for self.body.local_decls.

[Aaron1011]

@1000teslas I think the information you need already exists in closure_kind_origins().

You can see an example of retrieving this here:

rust/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs

Lines 295 to 298 in edeb631

	let tables = self.infcx.tcx.typeck(id.expect_local());
	let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(id.expect_local());
	tables.closure_kind_origins().get(hir_id).is_none()

and of using it:

rust/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

Lines 591 to 612 in edeb631

	match (found_kind, typeck_results.closure_kind_origins().get(hir_id)) {
	(ty::ClosureKind::FnOnce, Some((span, place))) => {
	err.span_label(
	*span,
	format!(
	"closure is `FnOnce` because it moves the \
	variable `{}` out of its environment",
	ty::place_to_string_for_capture(tcx, place)
	),
	);
	}
	(ty::ClosureKind::FnMut, Some((span, place))) => {
	err.span_label(
	*span,
	format!(
	"closure is `FnMut` because it mutates the \
	variable `{}` here",
	ty::place_to_string_for_capture(tcx, place)
	),
	);
	}
	_ => {}

I don't think you'll need to access the MIR Local

[JohnTitor]

Fixed by #81158