rustc doesn't detect whether a loop happens once or more than once or never, in obvious cases

I'm using issue #57553 to detect whether rustc thinks that a loop happens once or more than once.

So far, I see only the following as being detected to happen once, which is true:

loop {
  //some code here
  break;
}

and I see the following incorrectly detected to happen more than once:

loop {
   //code here
   if 1==1 { break; }  // loop happens once
}

for i in 1..1 { //  loop happens never
  //never-hit code here
}

for i in 1..=1 { // loop happens once
   //code here
}

Proof that all of the above is true (playground link):

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

struct NewType(i32);



fn main() {
    
    let mut v:Vec<NewType>=Vec::new();
   
    
    loop {
        println!("loop iteration");//hit once
        let a:NewType;
        change(&mut a); //true: "borrow of possibly uninitialized variable: `a`"
        v.push(a);
        break; // due to this break, the loop is detected as happening only once
    }
    
    loop {
        println!("loop iteration");//hit once
        let a:NewType;
        change(&mut a); //false: "value borrowed here after move", see https://github.com/rust-lang/rust/issues/57553
        v.push(a);// false: "value moved here, in previous iteration of loop"
        if 1==1 { // loop is no longer detected as happening only once due to this 'if'
          break;
        }
    }
    
    for i in 1..1 {
        println!("loop iteration");//never hit
        let a:NewType;
        change(&mut a); //false: "value borrowed here after move"
        v.push(a);// false: "value moved here, in previous iteration of loop"
        //break; //uncommenting this makes rust think the loop happens only once(even though it happens never) and thus reveals the true error: "borrow of possibly uninitialized variable: `a`"
    }
    
    for i in 1..=1 {
        println!("loop iteration");//hit once
        let a:NewType;
        change(&mut a); //false: "value borrowed here after move"
        v.push(a);// false: "value moved here, in previous iteration of loop"
    }
    
    for i in 1..=2 {
        println!("loop iteration");//hit twice
        let a:NewType;
        change(&mut a); //false: "value borrowed here after move"
        v.push(a);// false: "value moved here, in previous iteration of loop"
    }
    
    
}

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

So, what else this means? dead code isn't detected in obvious cases like(playground):

#![warn(dead_code)]

fn main() {
    for _ in 1..1 {
        //  loop happens never
        println!("never"); //not detected as dead code
    }
}

[scottmcm]

I believe this is intentional. Even things like if true and while false aren't detected. IIRC it's this way so that you can debug things easier, and borrowck doesn't sometimes do different things depending whether some situation happens to be something that the compiler managed to fold.

It's definitely expected for things like for _ in 1..0, since that goes through a ton of library code, and thus its dead-ness is not at all obvious to a compiler.

Can you elaborate on why you would want it to behave differently?

I believe this is intentional. Even things like if true and while false aren't detected. IIRC it's this way so that you can debug things easier, and borrowck doesn't sometimes do different things depending whether some situation happens to be something that the compiler managed to fold.

Can you elaborate on why you would want it to behave differently?

I don't know, I thought that since it's doing it for

loop {
  //some code here
  break;
}

then maybe it wants to do it for other cases too, but devs didn't get around to doing it, yet.

But, now considering how many cases it doesn't detect, compared to like only 1 that it does, maybe this one is just simply a side effect of something and thus, it wasn't intended to detect things like this for other/most cases. However the main reason for detecting such cases, I'd think, is for optimizing code. Other reason is for warning you when you do obvious dead code mistakes eg. for i in 1..1 when you meant for i in 1..=1 (ok, bad example). Even other reason(s) is issue #57553 where if the loop was detected to happen only once, a completely different (real/true) error would be shown, instead of the fake one where rust assumes a value moved which would only happen in loops that iterrate more than one time.

It's definitely expected for things like for _ in 1..0, since that goes through a ton of library code, and thus its dead-ness is not at all obvious to a compiler.

I'm not sure I understand, what do you mean here? It's expected to ...? do nothing? to (not?)warn as dead code? How does for _ in 1..0 go through a _ton_ of library code ? rust library? other people's library? Sorry, I'm not understanding :)

Upon further reflection, I believe you're right. I'm closing this.