case ast::NodeValue::As(expr) => {

            // Cast expressions are constant if the source value is constant.

            return isConstExpr(self, expr.value);

        },

        // Propagate constant value through the cast, adjusting integer

        // metadata to match the target type.

        if let value = constValueEntry(self, expr.value) {

            if let case ConstValue::Int(i) = value {

                if let range = integerRange(targetTy) {

                    match range {

                        case IntegerRange::Signed { bits, .. } =>

                            setNodeConstValue(self, node, constInt(i.magnitude, bits, true, i.negative)),

                        case IntegerRange::Unsigned { bits, .. } =>

                            setNodeConstValue(self, node, constInt(i.magnitude, bits, false, false)),

                    }

                }

            }

        }

/// Test `as` casts in constant expressions: widening, narrowing, sign changes, chaining.

@test fn testConstExprCast() throws (testing::TestError) {

    try expectConstFold("const A: i32 = 42; const B: u64 = A as u64;", 1, 42);

    try expectConstFold("const A: u64 = 10; const B: u8 = A as u8;", 1, 10);

    try expectConstFold("const A: i32 = 7; const B: u32 = A as u32;", 1, 7);

    try expectConstFold("const A: u32 = 100; const B: i32 = A as i32;", 1, 100);

    try expectConstFold("const A: u8 = 5; const B: u64 = (A as u32) as u64;", 1, 5);

    try expectConstFold("const A: u8 = 3; const B: u8 = 4; const C: i32 = (A as i32) + (B as i32);", 2, 7);

}

/// Test `as` cast in constant expressions used as array size.

@test fn testConstExprCastAsArraySize() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "const LEN: u64 = 4; const SIZE: u32 = LEN as u32; const ARR: [i32; SIZE] = [1, 2, 3, 4];";

    let result = try resolveProgramStr(&mut a, program);

    try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 2);

    let sym = super::symbolFor(&a, arrStmt)

        else throw testing::TestError::Failed;

    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data

        else throw testing::TestError::Failed;

    try testing::expect(arrType.length == 4);

}

//! returns: 0

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

const A: i32 = 42;

const B: u64 = A as u64;

const C: u8 = 10;

const D: i32 = C as i32;

const SIZE: u32 = 4;

const SHIFTED: u64 = SIZE as u64;

// Use a cast const expression as an array size.

const LEN: u32 = 8;

const LEN2: u32 = (LEN as u64) as u32;

static BUF: [u8; LEN2] = undefined;

// Cast const used in static data initializer.

const INIT_VAL: u8 = 0xFF;

const WIDE: u32 = INIT_VAL as u32;

// Cast with arithmetic.

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;

    return 0;

}