Mutating an immutable variable

[Islam-Imad]

// { dg-output "prime\r*\nnot_prime\r*\nprime\r*\nprime\r*\nnot_prime\r*\n" }
#![feature(no_core)]
#![no_core]
extern "C" {
    fn puts(s: *const i8);
}
extern "C" {
    fn printf(s: *const i8, ...);
}
fn dump(message: &str) {
    unsafe {
        let b = message as *const str;
        let c = b as *const i8;
        puts(c);
    }
}
fn is_prime(number: i32) -> bool {
    if number <= 1 {
        return false;
    }
    let i = 1;
    loop {
        i += 1;
        if i * i >= number {
            break;
        }
        if number % i != 0 {
            continue;
        }
        return false;
    }
    return true;
}

fn debug_prime(number: i32) {
    let state = is_prime(number);
    if state {
        dump("prime");
    } else {
        dump("not_prime");
    }
}

fn main() -> i32 {
    debug_prime(11);
    debug_prime(12);
    debug_prime(13);
    debug_prime(17);
    debug_prime(100);
    0
}

inside is_prime function variable i is immutable and still we can compile with gccrs.

rustc output :

~/projects/LLVM/hack> rustc rust.rs ; ./rust
error[E0384]: cannot assign twice to immutable variable `i`
  --> rust.rs:10:9
   |
 8 |     let i = 1;
   |         - first assignment to `i`
 9 |     loop {
10 |         i += 1;
   |         ^^^^^^ cannot assign twice to immutable variable
   |
help: consider making this binding mutable
   |
 8 |     let mut i = 1;
   |         +++

error: aborting due to 1 previous error

~/projects/LLVM/hack>       

[Islam-Imad]

it seems to be handled but i don't why it compiles.

[Islam-Imad]

@powerboat9 i will work on this :)
even if we miss to emit a flag that should prevent this from compiling why the backend compile with no problems ?