rustc can't parse large untyped literals correctly

[mahkoh]

0xFFFF_FFFF_FFFF_FFFF will be interpreted as -1 in certain situations where the correct type is known to be u64.

[huonw]

Why is being interpreted as -1 bad? It is exactly that.

Could you add a code example demonstrating the issue?

[mahkoh]

fn main() {
    match 1u64 {
        0...0xFFFF_FFFF_FFFF_FFFF => { },
        _ => { },
    }
}

[mahkoh]

test5.rs:3:9: 3:13 error: lower range bound must be less than upper [E0030]
test5.rs:3         0...0xFFFF_FFFF_FFFF_FFFF => { },
                   ^~~~

[thestinger]

@huonw: Generic literals are supposed to have an inferred type but Rust treats them as int in a few places.

[mahkoh]

I guess that means that

fn main() {
    match 1u64 {
        0...0xFFFF_FFFF_FFFF_FF => { },
        _ => { },
    }
}

which compiles correctly on 64 bit will fail to compile on 32 bit or, much worse, truncate the upper bound to something that fits in an int.

[steveklabnik]

Triage: same error today.

[vbezhenar]

The following program does not compile:

fn main() {
    let x: u64 = 0;
    match x {
        9223372036854775807 ... 9223372036854775808 => (),
        _ => (),
    }
}

The following program does compile:

fn main() {
    let x: u64 = 0;
    match x {
        9223372036854775808 ... 9223372036854775809 => (),
        _ => (),
    }
}

it's very misleading behavior.