Adding type annotation equivalent to existing type changes code semantics

[F001]

This piece of code can't compile:

fn main()
{
    let y = &mut 2i32;
    {
        let x = y;
        *x = 3;
    }
    println!("{}", y);
}

But, if we add the type annotation, it compiles:

fn main()
{
    let y = &mut 2i32;
    {
        let x: &mut i32 = y;
        *x = 3;
    }
    println!("{}", y);
}

I guess the later form triggers "auto-deref" mechanism, which equals to:

let x = &mut *y;

But this behaviour is still very confusing. Type annotation or not doesn't change the type of x at all. Type of x is always &mut i32. But they lead to different compile result. I have no idea whether should we fix it.

[jonas-schievink]

I don't think autoderef is involved here, the type of x still seems to be inferred to &mut i32. Looks like some weird interaction with reborrows (a reborrow is occurring in the second case but not the first).

[jonas-schievink]

Looks like a duplicate of #25899, but I think we should keep it open anyways since this is very confusing

[Mark-Simulacrum]

Well, actually, this isn't really a diagnostics issue--I'm going to nominate for a lang team discussion so that we can see what we want to do here, and can we do anything here. For reference the first example compiles with the following error today:

error[E0382]: use of moved value: `y`
 --> test.rs:8:20
  |
5 |         let x = y;
  |             - value moved here
...
8 |     println!("{}", y);
  |                    ^ value used here after move
  |
  = note: move occurs because `y` has type `&mut i32`, which does not implement the `Copy` trait

error: aborting due to previous error

[nikomatsakis]

The reason that this happens is that, in the second case, where the expected type is known, we will do a "reborrow coercion" (in particular, when coercing from &mut to &mut). This means that the variable is not considered "moved". In the first case, though, the target type is not known, and hence we consider it a move. This is suboptimal but not wrong (in general, annotating let can induce coercions and have other changes).

I think we could fix this (potentially) by detecting the case that we are coercing an &mut to an unknown type and pre-emptively inserting a &mut * reborrow. I think this can only make errors go away, and not cause them. Probably worth trying anyway. I'd be up to mentor this.