Passing a mut reference into an unconstrained function crashes the compiler

[zac-williamson]

Aim

Trying to work around #4244

Code:

use dep::std::field::bn254::assert_gt;

struct ListItem {
    key: Field,
    previous: Field,
    next: Field,
}

impl ListItem {
    fn default() -> ListItem {
        ListItem {
            key: 0,
            previous: 0,
            next: 0,
        }
    }
}

struct Map<Size> {
    entries: [ListItem; Size],
    size: Field,
    is_empty: bool,
    first_index: Field,
    last_index: Field,
}

unconstrained fn find_previous_key_location<Size>(map: Map<Size>, key: Field) -> (Field) {
    let mut found_index: Field = 0;
    found_index
}

unconstrained fn find_previous_key_location_nocopy<Size>(key: Field) -> (Field) {
    let mut found_index: Field = 0;
    found_index
}

unconstrained fn find_previous_key_location_crash<Size>(map: &mut Map<Size>, key: Field) -> (Field) {
    let mut found_index: Field = 0;
    found_index
}

impl<Size> Map<Size> {
    fn default() -> Map<Size> {
        Map{
            entries: [ListItem::default(); Size], // todo fix
            size: 0,
            is_empty: true,
            first_index: 0,
            last_index: 0,
        }
    }


    fn insert_crashy(&mut self, key: Field) {
        let previous_indexx = find_previous_key_location_crash(self, key);
        self.entries[previous_indexx].key = key;
    }

}

fn main(x: Field, y: pub Field) {
    let mut test_list: Map<50> = Map::default();
    test_list.insert_crashy(x);
    test_list.insert_crashy(x + y);
    test_list.insert_crashy(x + y * y);
}

Expected Behavior

no crash. Sad face.

Bug

compiler crashes

To Reproduce

1. nargo info
2. observe crash

Installation Method

None

Nargo Version

0.23.0

Additional Context

No response

Would you like to submit a PR for this Issue?

No

Support Needs

No response

[jfecher]

It isn't possible to pass a mutable reference from a constrained function into an unconstrained one since any mutations performed on it wouldn't be reflected back in the constrained function. For this reason, passing a mutable reference through this boundary is banned, although we should issue a compiler error rather than panic here.