case ast::NodeValue::BinOp(binop) => {

            // Binary expressions are constant if both operands are constant.

            return isConstExpr(self, binop.left) and isConstExpr(self, binop.right);

        },

        case ast::NodeValue::UnOp(unop) => {

            // Unary expressions are constant if the operand is constant.

            return isConstExpr(self, unop.value);

        },

/// Convert a [`ConstInt`] to its signed two's-complement representation.

fn constIntToSigned(c: ConstInt) -> i64 {

    if c.negative {

        return -(c.magnitude as i64);

    }

    return c.magnitude as i64;

}

/// Build a [`ConstInt`] from a signed result, preserving bit width and signedness.

fn constIntFromSigned(value: i64, bits: u8, signed: bool) -> ConstInt {

    if value < 0 {

        // Compute magnitude without signed overflow.

        let uval = value as u64;

        return ConstInt {

            magnitude: 0 - uval,

            bits,

            signed,

            negative: true,

        };

    }

    return ConstInt {

        magnitude: value as u64,

        bits,

        signed,

        negative: false,

    };

}

/// Try to fold a binary operation on two integer constants.

/// Returns the resulting constant value if successful.

fn foldIntBinOp(op: ast::BinaryOp, left: ConstInt, right: ConstInt) -> ?ConstValue {

    // Use the wider bit width and propagate signedness.

    let mut bits = left.bits;

    if right.bits > bits {

        bits = right.bits;

    }

    let signed = left.signed or right.signed;

    let l = constIntToSigned(left);

    let r = constIntToSigned(right);

    match op {

        // Shifts operate on unsigned magnitudes directly.

        case ast::BinaryOp::Shl => {

            return ConstValue::Int(ConstInt {

                magnitude: left.magnitude << right.magnitude, bits, signed, negative: left.negative,

            });

        },

        case ast::BinaryOp::Shr => {

            return ConstValue::Int(ConstInt {

                magnitude: left.magnitude >> right.magnitude, bits, signed, negative: left.negative,

            });

        },

        case ast::BinaryOp::Eq  => return ConstValue::Bool(l == r),

        case ast::BinaryOp::Ne  => return ConstValue::Bool(l != r),

        case ast::BinaryOp::Lt  => return ConstValue::Bool(l < r),

        case ast::BinaryOp::Gt  => return ConstValue::Bool(l > r),

        case ast::BinaryOp::Lte => return ConstValue::Bool(l <= r),

        case ast::BinaryOp::Gte => return ConstValue::Bool(l >= r),

        case ast::BinaryOp::Add => return ConstValue::Int(constIntFromSigned(l + r, bits, signed)),

        case ast::BinaryOp::Sub => return ConstValue::Int(constIntFromSigned(l - r, bits, signed)),

        case ast::BinaryOp::Mul => return ConstValue::Int(constIntFromSigned(l * r, bits, signed)),

        case ast::BinaryOp::Div => {

            if r == 0 {

                return nil;

            }

            return ConstValue::Int(constIntFromSigned(l / r, bits, signed));

        },

        case ast::BinaryOp::Mod => {

            if r == 0 {

                return nil;

            }

            return ConstValue::Int(constIntFromSigned(l % r, bits, signed));

        },

        case ast::BinaryOp::BitAnd => return ConstValue::Int(constIntFromSigned(l & r, bits, signed)),

        case ast::BinaryOp::BitOr  => return ConstValue::Int(constIntFromSigned(l | r, bits, signed)),

        case ast::BinaryOp::BitXor => return ConstValue::Int(constIntFromSigned(l ^ r, bits, signed)),

        else => return nil,

    }

}

/// Try to constant-fold a binary operation on two resolved operands.

/// Only folds when the result type is concrete.

fn tryFoldBinOp(self: *mut Resolver, node: *ast::Node, binop: ast::BinOp, resultTy: Type) {

    // Skip folding for untyped integer expressions. Their final type

    // depends on context, so attaching a signed constant value could

    // cause spurious range-check failures (e.g. `0 - 12` assigned to u8).

    if resultTy == Type::Int {

        return;

    }

    let leftVal = constValueFor(self, binop.left)

        else return;

    let rightVal = constValueFor(self, binop.right)

        else return;

    // Fold integer binary ops.

    if let case ConstValue::Int(leftInt) = leftVal {

        if let case ConstValue::Int(rightInt) = rightVal {

            if let result = foldIntBinOp(binop.op, leftInt, rightInt) {

                setNodeConstValue(self, node, result);

            }

            return;

        }

    }

    // Fold boolean binary ops.

    if let case ConstValue::Bool(l) = leftVal {

        if let case ConstValue::Bool(r) = rightVal {

            match binop.op {

                case ast::BinaryOp::And => setNodeConstValue(self, node, ConstValue::Bool(l and r)),

                case ast::BinaryOp::Or => setNodeConstValue(self, node, ConstValue::Bool(l or r)),

                case ast::BinaryOp::Eq => setNodeConstValue(self, node, ConstValue::Bool(l == r)),

                case ast::BinaryOp::Ne,

                     ast::BinaryOp::Xor => setNodeConstValue(self, node, ConstValue::Bool(l != r)),

                else => {}

            }

        }

    }

}

    // Try constant folding after both operands are resolved.

    tryFoldBinOp(self, node, binop, resultTy);

    // `3 * 1` uses untyped integer literals, so constant folding does not

    // produce a value. The repeat count requires a known compile-time value.

// Constant expression folding tests //////////////////////////////////////////

/// Resolve a program and verify that the constant at the given statement index

/// has the expected integer magnitude.

fn expectConstFold(program: *[u8], stmtIdx: u32, expected: u64)

    throws (testing::TestError)

{

    let mut a = testResolver();

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

    try expectNoErrors(&result);

    let stmt = try getBlockStmt(result.root, stmtIdx);

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

        else throw testing::TestError::Failed;

    let case super::SymbolData::Constant { value, .. } = sym.data

        else throw testing::TestError::Failed;

    let val = value else throw testing::TestError::Failed;

    let case super::ConstValue::Int(intVal) = val

        else throw testing::TestError::Failed;

    try testing::expect(intVal.magnitude == expected);

}

/// Test arithmetic constant folding: add, sub, mul, div.

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

    try expectConstFold("const A: i32 = 10; const B: i32 = 20; const C: i32 = A + B;", 2, 30);

    try expectConstFold("const A: i32 = 50; const B: i32 = 20; const C: i32 = A - B;", 2, 30);

    try expectConstFold("const A: i32 = 6; const B: i32 = 7; const C: i32 = A * B;", 2, 42);

    try expectConstFold("const A: i32 = 100; const B: i32 = 5; const C: i32 = A / B;", 2, 20);

}

/// Test bitwise constant folding: and, or, xor.

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

    try expectConstFold("const A: i32 = 0xFF; const B: i32 = 0x0F; const C: i32 = A & B;", 2, 0x0F);

    try expectConstFold("const A: i32 = 0xF0; const B: i32 = 0x0F; const C: i32 = A | B;", 2, 0xFF);

    try expectConstFold("const A: i32 = 0xFF; const B: i32 = 0x0F; const C: i32 = A ^ B;", 2, 0xF0);

}

/// Test shift constant folding.

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

    try expectConstFold("const A: i32 = 1; const B: i32 = A << 4;", 1, 16);

    try expectConstFold("const A: i32 = 32; const B: i32 = A >> 2;", 1, 8);

}

/// Test chained constant expressions (C depends on A + B, D depends on C).

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

    try expectConstFold("const A: i32 = 10; const B: i32 = 20; const C: i32 = A + B; const D: i32 = C * 2;", 3, 60);

}

/// Test constant expression used as array size.

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

    let mut a = testResolver();

    let program = "const A: u32 = 2; const B: u32 = 3; const SIZE: u32 = A + B; const ARR: [i32; SIZE] = [1, 2, 3, 4, 5];";

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

    try expectNoErrors(&result);

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

    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 == 5);

}

/// Test cross-module constant expression: a constant in one module references

/// a constant from another module via scope access.

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

    let mut a = testResolver();

    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod consts; mod app;", &mut arena);

    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const BASE: i32 = 100;", &mut arena);

    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const DERIVED: i32 = consts::BASE + 50;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);

    try expectNoErrors(&result);

}

/// Test cross-module constant expression used as array size.

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

    let mut a = testResolver();

    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod consts; mod app;", &mut arena);

    let constsId = try registerModule(&mut MODULE_GRAPH, rootId, "consts", "pub const WIDTH: u32 = 8; pub const HEIGHT: u32 = 4;", &mut arena);

    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::consts; const TOTAL: u32 = consts::WIDTH * consts::HEIGHT; static BUF: [u8; TOTAL] = undefined;", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);

    try expectNoErrors(&result);

}

/// Test that non-constant expressions in const declarations are still rejected.

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

    let mut a = testResolver();

    let program = "fn value() -> i32 { return 1; } const BAD: i32 = value() + 1;";

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

    let err = try expectError(&result);

    let case super::ErrorKind::ConstExprRequired = err.kind

        else throw testing::TestError::Failed;

}

/// Test unary negation in constant expressions.

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

    let mut a = testResolver();

    let program = "const A: i32 = 10; const B: i32 = -A;";

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

    try expectNoErrors(&result);

}

/// Test unary not in constant expressions.

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

    let mut a = testResolver();

    let program = "const A: bool = true; const B: bool = not A;";

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

    try expectNoErrors(&result);

}

//! returns: 0

/// Test that constant expressions referencing other constants

/// can be used as array sizes.

const ROWS: u32 = 3;

const COLS: u32 = 4;

const TOTAL: u32 = ROWS * COLS;

static DATA: [i32; TOTAL] = undefined;

@default fn main() -> i32 {

    // Verify the array has the expected length.

    if DATA.len != 12 { return 1; }

    return 0;

}

//! returns: 0

/// Test that constant expressions can reference other constants,

/// including arithmetic on constants.

const A: i32 = 10;

const B: i32 = 20;

const C: i32 = A + B;

const D: i32 = C * 2;

const E: i32 = D - A;

const F: i32 = E / 5;

const G: i32 = A % 3;

const H: i32 = A | B;

const I: i32 = A & B;

const J: i32 = A ^ B;

const K: i32 = A << 2;

const L: i32 = B >> 1;

@default fn main() -> i32 {

    if C != 30 { return 1; }

    if D != 60 { return 2; }

    if E != 50 { return 3; }

    if F != 10 { return 4; }

    if G != 1 { return 5; }

    if H != 30 { return 6; }

    if I != 0 { return 7; }

    if J != 30 { return 8; }

    if K != 40 { return 9; }

    if L != 10 { return 10; }

    return 0;

}