Cannot bitshift without using a literal (runtime bitshift failure/regression)

[tsujp]

Aim

To bitshift by values only known at runtime.

Expected Behavior

I'd expect this suite of tests to pass:

// PASSES.
fn bitshift_literal_0() -> u64 {
    let mut bits: u64 = 0;
    bits |= 1 << 0;

    bits
}

// PASSES.
fn bitshift_literal_4() -> u64 {
    let mut bits: u64 = 0;
    bits |= 1 << 4;

    bits
}

// FAILS.
fn bitshift_variable(idx: u64) -> u64 {
    let mut bits: u64 = 0;
    // ERROR:
    // [bitshift_error] Testing test_bitshift_variable... The application panicked (crashed).
    // Message:  internal error: entered unreachable code: ICE: Truncation attempted on non-integer
    // Location: crates/noirc_evaluator/src/ssa/ssa_gen/context.rs:318
    bits |= 1 << idx;

    bits
}

// PASSES.
#[test]
fn test_bitshift_literal() {
    let result_0 = bitshift_literal_0();
    assert(result_0 == 1);

    let result_4 = bitshift_literal_4();
    assert(result_4 == 16);
}

// FAILS.
#[test]
fn test_bitshift_variable() {
    let result_0 = bitshift_variable(0);
    assert(result_0 == 1);

    let result_4 = bitshift_variable(4);
    assert(result_4 == 16);
}

Bug

Function bitshift_variable fails with:

[bitshift_error] Testing test_bitshift_variable... The application panicked (crashed).
Message:  internal error: entered unreachable code: ICE: Truncation attempted on non-integer
Location: crates/noirc_evaluator/src/ssa/ssa_gen/context.rs:318

To Reproduce

1. Use Nargo binary (versioned below).
2. Paste in code above.
3. Observe test failure.

Installation Method

Binary

Nargo Version

nargo 0.10.3 (git version hash: 2db759f, is dirty: false)

Additional Context

• This same code passes on nargo 0.9.0 (git version hash: ef91286b920fb3e17c7368839a93ccad2441edc8, is dirty: false)
• macOS aarch64.

Would you like to submit a PR for this Issue?

No

Support Needs

No response

[jfecher]

Looks possibly related to #2250. I wouldn't be surprised since both left and right shifts use the same pow method internally.

[tsujp]

Looks possibly related to #2250. I wouldn't be surprised since both left and right shifts use the same pow method internally.

This may help but if all operands to the bitshift expression are variables then it works, so this is fine:

// Works
fn bitshift_variable(base: u64, idx: u64) -> u64 {
    let mut bits: u64 = 0;
    bits |= base << idx; // Same as in OP, literal `1` replaced with `base`.

    bits
}

Probably something to do with constant expression optimisation or something? I'm not too familiar with the compiler internals. I had a gander but nothing obvious to me.