borrowck compiler errors for upvars contain "spurious" dereferences

[arielb1]

STR

fn main() {
    let mut y = 0;
    || {
        let b = &y;
        y += 1;
        *b
    };
}

Result

error[E0506]: cannot assign to `**y` because it is borrowed
 --> src/main.rs:5:9
  |
4 |         let b = &y;
  |                  - borrow of `**y` occurs here
5 |         y += 1;
  |         ^^^^^^ assignment to borrowed `**y` occurs here

error: aborting due to previous error

y is an integer, so **y isn't actually a thing. We emit the dereferences because there are layers of indirection before we get to the upvar, but they aren't actually a part of the user-visible syntax.

[nikomatsakis]

I believe that to fix this we should rework a bit the approach we took in #45938. In particular, we can use the upvar_decls field on the Mir type:

rust/src/librustc/mir/mod.rs

Lines 112 to 114 in 01e979f

	/// Names and capture modes of all the closure upvars, assuming
	/// the first argument is either the closure or a reference to it.
	pub upvar_decls: Vec<UpvarDecl>,

This field gives access to information about the variables that the closure captures from its environment. In particular, it gives us their name, and also whether or not they are captured by reference.

rust/src/librustc/mir/mod.rs

Lines 544 to 551 in 01e979f

	/// A closure capture, with its name and mode.
	#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
	pub struct UpvarDecl {
	pub debug_name: Name,
	/// If true, the capture is behind a reference.
	pub by_ref: bool
	}

So basically I think we need the following subroutines. First, something that checks, for a given lvalue, if it is a reference to an "upvar field":

/// If this is a field projection, and the field is being projected from a closure type,
/// then returns the index of the field being projected. Note that this closure will always
/// be `self` in the current MIR, because that is the only time we directly access the fields
/// of a closure type.
fn is_upvar_field_projection(lvalue: Lvalue<'tcx>) -> Option<usize> { ... }

Then, on every dereference projection, we can check if it is a dereference of an upvar-field- projection and, if so, skip the *, so logic something like this:

if let Some(var_index) = self.is_upvar_field_projection(&proj.base) {
    if self.mir.upvars[var_index].by_ref {
        return self.mir.upvars[var_index].name;
    }
}

return format!("*{}", self.base);

We must also check, when you have a field projection, is this is an upvar_field_projection and if so return the name of the upvar, as we are doing now. (Note that if this IS by-ref upvar, it will only ever be accessed inside of a deref-lvalue.)

[nikomatsakis]

cc @vramana, who may want to do this as follow-up to the other PR =)

[arielb1]

I think @vramana is working on this