Compiler panics with Cannot flatten a dynamic array when returning an array from memory

[TomAFrench]

Aim

I would like to prove the following program

fn main(mut x: [Field; 256], index: u8) -> pub [Field; 256] {
    x[index] = 0;
    x
}

Expected Behavior

This should be able to be compiled to a circuit where I write x into memory, write 0 at index index in this memory, then read out the entirety of the block of memory to form the return value.

Bug

The compiler produces the SSA

After Dead Instruction Elimination:
acir fn main f0 {
  b0(v0: [Field; 256], v1: u8):
    v22 = array_set v0, index v1, value Field 0
    return v22
}

acirgen then panics with

The application panicked (crashed).
Message:  internal error: entered unreachable code: Cannot flatten a dynamic array
Location: compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs:1411

This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.
If there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml

To Reproduce

1. compile the above program

Installation Method

Compiled from source

Nargo Version

noirc version = 0.23.0+bdf64ed81d7f34d6478ed9bde5b69e45d171d5f0

Additional Context

No response

Would you like to submit a PR for this Issue?

No

Support Needs

No response

[LHerskind]

Seems to also happen on non-returned values (or might be from the sha256? I ran into it when trying to do assertions on the following:

fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {
    let mut current = leaf;
    let mut index = _index;

    for i in 0..2 {
        let mut hash_input = [0; 64];
        let offset = i * 32;
        let is_right = (index & 1) != 0;
        let a = if is_right { 32 } else { 0 };
        let b = if is_right { 0 } else { 32 };

        for j in 0..32 {
            hash_input[j + a] = current[j];
            hash_input[j + b] = path[offset + j];
        }

        current = sha256(hash_input);
        index = index >> 1;
    }
    // Either of the following two lines will make it fail with `Cannot flatten a dynamic array`
    // println(current);
    // assert(root == current);
}

On noirc version = 0.23.0+5be9f9d7e2f39ca228df10e5a530474af0331704

[TomAFrench]

or might be from the sha256?

Yep, blackbox functions are another situation where we flatten values.