bit_shift_comptime panics in debug mode

[TomAFrench]

I'm getting a panic on these lines when compiling bit_shift_comptime in debug mode.

noir/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs

Lines 454 to 456 in 36dcd48

	if max_rhs_bits != 0 {
	max_q_bits = max_bit_size - max_rhs_bits + 1;
	}

[TomAFrench]

The minimal reproduction is

fn main() {
    let a: u1 = 1 >> 1;
    assert(a == 0);
}

This gets compiled down to

acir fn main f0 {
  b0(v0: u64):
    v10 = div u1 1, Field 2
    constrain v10 == u1 0
    return 
}

We should be able to compile this down to an empty circuit. The issue is that when we try and simplify 1 >> 1 we assume that rhs conforms to the same max number of bits as lhs. This means that when we truncate the rhs down to bit_size then 2 gets truncated down to zero.

noir/compiler/noirc_evaluator/src/ssa/ir/instruction.rs

Lines 783 to 800 in 36dcd48

	Type::Numeric(NumericType::Unsigned { bit_size }) => {
	let function = self.operator.get_u128_function();
	let lhs = truncate(lhs.try_into_u128()?, *bit_size);
	let rhs = truncate(rhs.try_into_u128()?, *bit_size);
	// The divisor is being truncated into the type of the operand, which can potentially
	// lead to the rhs being zero.
	// If the rhs of a division is zero, attempting to evaluate the divison will cause a compiler panic.
	// Thus, we do not evaluate the division in this method, as we want to avoid triggering a panic,
	// and the operation should be handled by ACIR generation.
	if matches!(self.operator, BinaryOp::Div) && rhs == 0 {
	return None;
	}
	let result = function(lhs, rhs);
	truncate(result, *bit_size).into()
	}

The compiler then thinks we're performing a division by zero so defers to ACIR generation where we get the final panic.

[guipublic]

I cannot reproduce this issue, so I close it.