//! returns: 0

/// Test that `as` casts work in constant expressions.

// Widening, narrowing, sign changes.
const A: i32 = 42;
const B: u64 = A as u64;
const C: u8 = 10;
const D: i32 = C as i32;
const SHIFTED: u64 = 4 as u64;

// Chained casts.
const LEN: u32 = 8;
const LEN2: u32 = (LEN as u64) as u32;
static BUF: [u8; LEN2] = undefined;

// Cast of unsuffixed literal arithmetic.
const E: u32 = (3 + 4) as u32;
// Nested casts of literal arithmetic.
const F: u32 = ((3 + 4) as u64) as u32;
// Cast + arithmetic.
const G: u32 = (3 + 4) as u32 + 1;
// Arithmetic with cast subexprs.
const H: i32 = (2 as i32) * (3 + 4);

// Cast in static data initializer.
const INIT_VAL: u8 = 0xFF;
const WIDE: u32 = INIT_VAL as u32;

// Typed const * typed const through cast.
const X: u8 = 3;
const Y: u8 = 4;
const Z: i32 = (X as i32) * (Y as i32);

@default fn main() -> i32 {
    assert BUF.len == 8;
    assert WIDE == 255;
    assert Z == 12;
    assert E == 7;
    assert F == 7;
    assert G == 8;
    assert H == 14;
    return 0;
}