in loops, the error "borrow of possibly uninitialized variable" is overwritten by "borrow of moved value" in certain case(s)

[ghost]

In loops that are detected to happen more than once, the true error error[E0381]: borrow of possibly uninitialized variable: is overwritten by another error that doesn't seem to actually apply at all: error[E0382]: borrow of moved value:.

This happens possibly due to #52669 having been fixed.

Simple example (playground) follows, which is showing the fake error error[E0382]: borrow of moved value:; to see true error just uncomment the last break; line:

#![allow(unused_variables)]
#![allow(dead_code)]

struct NewType(i32);

fn main() {
    
    let mut v:Vec<NewType>=Vec::new();
    
    
    loop {
    //for i in 1..1 {
        //println!("iter{}",i);
        
        let a:NewType;
        //let mut a:NewType;
        //let a:NewType=NewType(3);
        //let mut a:NewType=NewType(3);//no errors with this line
        change(&mut a);//true but only happens without the "v.push(a)" below : "borrow of possibly uninitialized variable: `a`"
        v.push(a); //if this is uncommented then true error "borrow of possibly uninitialized variable: `a`" is overwritten by "borrow of moved value: `a`" and "value moved here, in previous iteration of loop"
       
        if 1==1 { //this breaks loop detection as happening only once(which a non-if break would do)
          break;
        }
        //break; //XXX uncomment this to see true error!
    }
}

fn change(i: &mut NewType) {
    *i=NewType(1);
}

Tested with rust nightly 2018, 11 Jan 2019 version, on playground.

Pedantic example on playground

[ibraheemdev]

I'm still getting the error on the playground with Rust 1.49:

fn blah() {
    loop {
        let blah: Option<String>; 
        if true {
            blah = Some("".to_string());
        }
        
        if let Some(blah) = blah.as_ref() {
            // ...
        }
    }
}

error[E0382]: borrow of moved value: `blah`
  --> src/lib.rs:8:29
   |
3  |         let blah: Option<String>;
   |             ---- move occurs because `blah` has type `Option<String>`, which does not implement the `Copy` trait
...
8  |         if let Some(blah) = blah.as_ref() {
   |                             ^^^^ value borrowed here after move
...
11 |     }
   |     - value moved here, in previous iteration of loop

[kadiwa4]

Fixed by #87998 and tested in tests/ui/moves/issue-72649-uninit-in-loop.rs.

[estebank]

Current output:

error[E0381]: used binding `a` isn't initialized
  --> src/main.rs:19:16
   |
15 |         let a:NewType;
   |             - binding declared here but left uninitialized
...
19 |         change(&mut a);//true but only happens without the "v.push(a)" below : "borrow of possibly uninitialized variable: `a`"
   |                ^^^^^^ `a` used here but it isn't initialized
   |
help: consider assigning a value
   |
15 |         let a:NewType = /* value */;
   |                       +++++++++++++

error[E0381]: used binding `blah` is possibly-uninitialized
 --> src/lib.rs:8:29
  |
3 |         let blah: Option<String>; 
  |             ---- binding declared here but left uninitialized
4 |         if true {
5 |             blah = Some("".to_string());
  |             ----
  |             |
  |             binding initialized here in some conditions
  |             binding initialized here in some conditions
...
8 |         if let Some(blah) = blah.as_ref() {
  |                             ^^^^ `blah` used here but it is possibly-uninitialized

We should remove the duplicated label, but other than that this is indeed fixed, likely by the PR linked above.