makepad/libs/relax/compiler/tests/n01_round30_overflow_reject.rs

// compile-fail: each initializer must report E0080, with overflow checks off too.
const U8_ADD: u8 = { let x = 255u8; x + 1 };
const U8_SUB: u8 = { let x = 0u8; x - 1 };
const U8_MUL: u8 = { let x = 255u8; x * 2 };
const U8_SHL: u8 = { let n = 8u32; 1u8 << n };
const U8_SHR: u8 = { let n = -1i32; 1u8 >> n };
const U8_ZERO: u8 = { let n = 0u8; 1u8 / n };
const U8_REMZERO: u8 = { let n = 0u8; 1u8 % n };
const I8_ADD: i8 = { let x = 127i8; x + 1 };
const I8_SUB: i8 = { let x = -128i8; x - 1 };
const I8_MUL: i8 = { let x = 127i8; x * 2 };
const I8_SHL: i8 = { let n = 8u32; 1i8 << n };
const I8_SHR: i8 = { let n = -1i32; 1i8 >> n };
const I8_ZERO: i8 = { let n = 0i8; 1i8 / n };
const I8_REMZERO: i8 = { let n = 0i8; 1i8 % n };
const I8_NEG: i8 = { let x = -128i8; -x };
const I8_DIVMIN: i8 = { let x = -128i8; x / -1 };
const I8_REMMIN: i8 = { let x = -128i8; x % -1 };
const U16_ADD: u16 = { let x = 65535u16; x + 1 };
const U16_SUB: u16 = { let x = 0u16; x - 1 };
const U16_MUL: u16 = { let x = 65535u16; x * 2 };
const U16_SHL: u16 = { let n = 16u32; 1u16 << n };
const U16_SHR: u16 = { let n = -1i32; 1u16 >> n };
const U16_ZERO: u16 = { let n = 0u16; 1u16 / n };
const U16_REMZERO: u16 = { let n = 0u16; 1u16 % n };
const I16_ADD: i16 = { let x = 32767i16; x + 1 };
const I16_SUB: i16 = { let x = -32768i16; x - 1 };
const I16_MUL: i16 = { let x = 32767i16; x * 2 };
const I16_SHL: i16 = { let n = 16u32; 1i16 << n };
const I16_SHR: i16 = { let n = -1i32; 1i16 >> n };
const I16_ZERO: i16 = { let n = 0i16; 1i16 / n };
const I16_REMZERO: i16 = { let n = 0i16; 1i16 % n };
const I16_NEG: i16 = { let x = -32768i16; -x };
const I16_DIVMIN: i16 = { let x = -32768i16; x / -1 };
const I16_REMMIN: i16 = { let x = -32768i16; x % -1 };
const U32_ADD: u32 = { let x = 4294967295u32; x + 1 };
const U32_SUB: u32 = { let x = 0u32; x - 1 };
const U32_MUL: u32 = { let x = 4294967295u32; x * 2 };
const U32_SHL: u32 = { let n = 32u32; 1u32 << n };
const U32_SHR: u32 = { let n = -1i32; 1u32 >> n };
const U32_ZERO: u32 = { let n = 0u32; 1u32 / n };
const U32_REMZERO: u32 = { let n = 0u32; 1u32 % n };
const I32_ADD: i32 = { let x = 2147483647i32; x + 1 };
const I32_SUB: i32 = { let x = -2147483648i32; x - 1 };
const I32_MUL: i32 = { let x = 2147483647i32; x * 2 };
const I32_SHL: i32 = { let n = 32u32; 1i32 << n };
const I32_SHR: i32 = { let n = -1i32; 1i32 >> n };
const I32_ZERO: i32 = { let n = 0i32; 1i32 / n };
const I32_REMZERO: i32 = { let n = 0i32; 1i32 % n };
const I32_NEG: i32 = { let x = -2147483648i32; -x };
const I32_DIVMIN: i32 = { let x = -2147483648i32; x / -1 };
const I32_REMMIN: i32 = { let x = -2147483648i32; x % -1 };
const U64_ADD: u64 = { let x = 18446744073709551615u64; x + 1 };
const U64_SUB: u64 = { let x = 0u64; x - 1 };
const U64_MUL: u64 = { let x = 18446744073709551615u64; x * 2 };
const U64_SHL: u64 = { let n = 64u32; 1u64 << n };
const U64_SHR: u64 = { let n = -1i32; 1u64 >> n };
const U64_ZERO: u64 = { let n = 0u64; 1u64 / n };
const U64_REMZERO: u64 = { let n = 0u64; 1u64 % n };
const I64_ADD: i64 = { let x = 9223372036854775807i64; x + 1 };
const I64_SUB: i64 = { let x = -9223372036854775808i64; x - 1 };
const I64_MUL: i64 = { let x = 9223372036854775807i64; x * 2 };
const I64_SHL: i64 = { let n = 64u32; 1i64 << n };
const I64_SHR: i64 = { let n = -1i32; 1i64 >> n };
const I64_ZERO: i64 = { let n = 0i64; 1i64 / n };
const I64_REMZERO: i64 = { let n = 0i64; 1i64 % n };
const I64_NEG: i64 = { let x = -9223372036854775808i64; -x };
const I64_DIVMIN: i64 = { let x = -9223372036854775808i64; x / -1 };
const I64_REMMIN: i64 = { let x = -9223372036854775808i64; x % -1 };
const U128_ADD: u128 = { let x = 340282366920938463463374607431768211455u128; x + 1 };
const U128_SUB: u128 = { let x = 0u128; x - 1 };
const U128_MUL: u128 = { let x = 340282366920938463463374607431768211455u128; x * 2 };
const U128_SHL: u128 = { let n = 128u32; 1u128 << n };
const U128_SHR: u128 = { let n = -1i32; 1u128 >> n };
const U128_ZERO: u128 = { let n = 0u128; 1u128 / n };
const U128_REMZERO: u128 = { let n = 0u128; 1u128 % n };
const I128_ADD: i128 = { let x = 170141183460469231731687303715884105727i128; x + 1 };
const I128_SUB: i128 = { let x = -170141183460469231731687303715884105728i128; x - 1 };
const I128_MUL: i128 = { let x = 170141183460469231731687303715884105727i128; x * 2 };
const I128_SHL: i128 = { let n = 128u32; 1i128 << n };
const I128_SHR: i128 = { let n = -1i32; 1i128 >> n };
const I128_ZERO: i128 = { let n = 0i128; 1i128 / n };
const I128_REMZERO: i128 = { let n = 0i128; 1i128 % n };
const I128_NEG: i128 = { let x = -170141183460469231731687303715884105728i128; -x };
const I128_DIVMIN: i128 = { let x = -170141183460469231731687303715884105728i128; x / -1 };
const I128_REMMIN: i128 = { let x = -170141183460469231731687303715884105728i128; x % -1 };
const SHIFT_HIGH: u8 = { let n = 1u128 << 64; 1u8 << n };
const SHIFT_ASSIGN_HIGH: u8 = { let n = 1u128 << 64; let mut x = 1u8; x <<= n; x };
#[test]
fn rejected_const_operations() {
    assert_eq!(U8_ADD, 0);
    assert_eq!(U8_SUB, 0);
    assert_eq!(U8_MUL, 0);
    assert_eq!(U8_SHL, 0);
    assert_eq!(U8_SHR, 0);
    assert_eq!(U8_ZERO, 0);
    assert_eq!(U8_REMZERO, 0);
    assert_eq!(I8_ADD, 0);
    assert_eq!(I8_SUB, 0);
    assert_eq!(I8_MUL, 0);
    assert_eq!(I8_SHL, 0);
    assert_eq!(I8_SHR, 0);
    assert_eq!(I8_ZERO, 0);
    assert_eq!(I8_REMZERO, 0);
    assert_eq!(I8_NEG, 0);
    assert_eq!(I8_DIVMIN, 0);
    assert_eq!(I8_REMMIN, 0);
    assert_eq!(U16_ADD, 0);
    assert_eq!(U16_SUB, 0);
    assert_eq!(U16_MUL, 0);
    assert_eq!(U16_SHL, 0);
    assert_eq!(U16_SHR, 0);
    assert_eq!(U16_ZERO, 0);
    assert_eq!(U16_REMZERO, 0);
    assert_eq!(I16_ADD, 0);
    assert_eq!(I16_SUB, 0);
    assert_eq!(I16_MUL, 0);
    assert_eq!(I16_SHL, 0);
    assert_eq!(I16_SHR, 0);
    assert_eq!(I16_ZERO, 0);
    assert_eq!(I16_REMZERO, 0);
    assert_eq!(I16_NEG, 0);
    assert_eq!(I16_DIVMIN, 0);
    assert_eq!(I16_REMMIN, 0);
    assert_eq!(U32_ADD, 0);
    assert_eq!(U32_SUB, 0);
    assert_eq!(U32_MUL, 0);
    assert_eq!(U32_SHL, 0);
    assert_eq!(U32_SHR, 0);
    assert_eq!(U32_ZERO, 0);
    assert_eq!(U32_REMZERO, 0);
    assert_eq!(I32_ADD, 0);
    assert_eq!(I32_SUB, 0);
    assert_eq!(I32_MUL, 0);
    assert_eq!(I32_SHL, 0);
    assert_eq!(I32_SHR, 0);
    assert_eq!(I32_ZERO, 0);
    assert_eq!(I32_REMZERO, 0);
    assert_eq!(I32_NEG, 0);
    assert_eq!(I32_DIVMIN, 0);
    assert_eq!(I32_REMMIN, 0);
    assert_eq!(U64_ADD, 0);
    assert_eq!(U64_SUB, 0);
    assert_eq!(U64_MUL, 0);
    assert_eq!(U64_SHL, 0);
    assert_eq!(U64_SHR, 0);
    assert_eq!(U64_ZERO, 0);
    assert_eq!(U64_REMZERO, 0);
    assert_eq!(I64_ADD, 0);
    assert_eq!(I64_SUB, 0);
    assert_eq!(I64_MUL, 0);
    assert_eq!(I64_SHL, 0);
    assert_eq!(I64_SHR, 0);
    assert_eq!(I64_ZERO, 0);
    assert_eq!(I64_REMZERO, 0);
    assert_eq!(I64_NEG, 0);
    assert_eq!(I64_DIVMIN, 0);
    assert_eq!(I64_REMMIN, 0);
    assert_eq!(U128_ADD, 0);
    assert_eq!(U128_SUB, 0);
    assert_eq!(U128_MUL, 0);
    assert_eq!(U128_SHL, 0);
    assert_eq!(U128_SHR, 0);
    assert_eq!(U128_ZERO, 0);
    assert_eq!(U128_REMZERO, 0);
    assert_eq!(I128_ADD, 0);
    assert_eq!(I128_SUB, 0);
    assert_eq!(I128_MUL, 0);
    assert_eq!(I128_SHL, 0);
    assert_eq!(I128_SHR, 0);
    assert_eq!(I128_ZERO, 0);
    assert_eq!(I128_REMZERO, 0);
    assert_eq!(I128_NEG, 0);
    assert_eq!(I128_DIVMIN, 0);
    assert_eq!(I128_REMMIN, 0);
    assert_eq!(SHIFT_HIGH, 0);
    assert_eq!(SHIFT_ASSIGN_HIGH, 0);
}