Assinging to an i32 variable a binary representation of i32::MIN fails to compile

[psvri]

I tried this code:

fn main() {
    let x: i32 = 0b1000_0000_0000_0000_0000_0000_0000_0000i32;
    println!("{}", x);
}

playground link

I expected the code to compile since its i am assigning into x binary representation of i32::MIN, instead the compiler throws an error.

Meta

rustc --version --verbose:

1.67.1

Backtrace

   Compiling playground v0.0.1 (/playground)
error: literal out of range for `i32`
 --> src/main.rs:2:18
  |
2 |     let x: i32 = 0b1000_0000_0000_0000_0000_0000_0000_0000i32;
  |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the type `u32` instead: `0b1000_0000_0000_0000_0000_0000_0000_0000u32`
  |
  = note: the literal `0b1000_0000_0000_0000_0000_0000_0000_0000i32` (decimal `2147483648`) does not fit into the type `i32` and will become `-2147483648i32`
  = note: `#[deny(overflowing_literals)]` on by default

error: could not compile `playground` due to previous error

[psvri]

Similar issue happens with i16 as well where the below code dosen't compile

fn main() {
    let x: i16 = 0b1000_0000_0000_0000i16;
    println!("{}", x);
}

[wwylele]

This looks intended to me. The binary literal 0b..., along with all other integer literals, represents the number in a more mathematical sense, instead of in a memory layout sense, so 0b1000_0000_0000_0000_0000_0000_0000_0000 really means the integer 2147483648, not -2147483648 (=i32::MIN)

[psvri]

A similar code compiles in c++ and hence I assumed it was a bug.

#include <iostream>
using namespace std;
int main()
{
    int32_t x = 0b10000000000000000000000000000000;
    cout<<x;
    return 0;
}

[wwylele]

The C++ code works because C++ has implicit integer conversion. On a typical int = 32bit platform, 0b10000000000000000000000000000000 means 2147483648 (in both rust and C++), and is typed unsigned int in C++ (because it doesn't fit in int. "The type of the integer literal is the first type in which the value can fit"), and then when you assign it back to int32_t, the result is {implementation-defined (C++17 or earlier)} / {reinterpreted in terms of 2's complement(C++20 or later)}, which gives you back i32::MIN. Its rust equivalent code should be

fn main() {
    let x: i32 = 0b1000_0000_0000_0000_0000_0000_0000_0000u32 as i32;
    println!("{}", x);
}

[psvri]

Ohh okay. Thanks for this information. Now I too feel that this behavior was intentional.

[saethlin]

So it sounds like the problem here is that the diagnostic doesn't teach all this.

[wwylele]

A nice diagnostic would be that, if an overflowing literal has "sign bit" set, guess the user wants to express a negative number in 2's complement, and suggest using the negative number literal

[edward-shen]

I can try and give this a shot.

@rustbot claim