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

[Stargateur]

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

Thus that very weird and probably a bad practice in most case. Doing binary operation on signed number is never a good thing in my book.

[workingjubilee]

In that case, the compiler emits an error if you do it at compile-time since it's a case of the operation inducing wraparound (which lands on the same value). That's not a satisfying answer as to why the mere literal fails to compile.

[edward-shen]

Sorry, I haven't had the time to work on this. Releasing in hopes someone can pick it up.

@rustbot release-assignment

[nicklimmm]

I'd like to give this a try, but I need some assistance as I have no experience working on the compiler.

@rustbot claim

My idea is to add another note and help when the literal fits in the unsigned variant, but not the signed variant (in the provided example, u32 and i32 respectively)

Facing a blocker now. How could one emit multiple suggestions (that share the same span) or "help"s?

Reference: OverflowingBinHexSub definition

#[derive(Subdiagnostic)]
pub enum OverflowingBinHexSub<'a> {
    #[suggestion(
        lint_suggestion,
        code = "{sans_suffix}{suggestion_ty}",
        applicability = "machine-applicable"
    )]
    Suggestion {
        #[primary_span]
        span: Span,
        suggestion_ty: &'a str,
        sans_suffix: &'a str,
    },
    #[help(lint_help)]
    Help { suggestion_ty: &'a str },
}

Would love to hear suggestions or guidance :)

[psvri]

Thank you all for closing this