fix: Consume correct number of fields when printing references

[aakoshh]

Description

Problem*

Resolves #9578

Summary*

Fixes decode_printable_value handling reference types to consume a number of fields not based on the type, but how a reference to the type is passed to the foreign call handler.

Additional Context

The code assumed that when it encounters a PrintableType::Reference { typ, .. } then it can decode a typ from the following fields in the iterator. Then, when it came to displaying the value, it printed either <<ref>> or <<mutable ref>>, the decoded value wasn't actually shown.

Being able to decode the referenced value may have been the original intention (although if that's the case I don't know why it would not have display it), but that's now what was we got in practice. Instead we got what appears to be the memory addresses in the Brillig VM, which is a number above 32,000. The number of these addresses depends on the type: an Array is represented by a single number, while a Slice is 2 numbers, a Tuple depends on its fields.

It is unclear to me whether this is intentional. I guess we could use the address for debug purposes, but an actual foreign call handler would probably find little value in it. Furthermore, it seems to me that we can't handle enums this way: if we can't tell the value of the tag, we don't know how many fields will be in the data, where the rest continues.

ACIR

Printing references doesn't seem to work at all in ACIR, because it would require passing references to Brillig, which is impossible. Instead we get a compile error such as this:

error: Could not resolve some references to the array. All references must be resolved at compile time
  ┌─ src/main.nr:2:18
  │
2 │     println(&mut 1);

Brillig

It is possible to print references in Brillig, and debug_vars::assign_var uses it directly to store a printable value, for example:

❯ cargo run -q -p nargo_cli -- debug --force --silence-warnings
...
> next
At opcode 0:0.26 :: Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }
At src/main.nr:3:10
  1    fn main(mut a: u32) -> pub u32 {
  2        let b = &mut a;
  3 ->     *b = *b + 1;
  4        a
  5    }
> vars
main(mut a)
  a:UnsignedInteger { width: 32 } = 1
  b:Reference { typ: UnsignedInteger { width: 32 }, mutable: true } = <<mutable ref>>
> memory
0 = 3: u32
1 = 32839: u32
2 = 1: u32
4 = 1: field
5 = 32838: u32
6 = 0: u32
8 = 1: u32
32771 = true: u1
32772 = 30720: u32
32836 = 1: u32
32838 = 1: u32

Notice how b is shown as b:Reference { typ: UnsignedInteger { width: 32 }, mutable: true } = <<mutable ref>>, so we neither learn where b points nor what its current value is. I wonder if we could make it more useful by either displaying the address values, or actually passing the current value.

Example

Here's what the data used in the integration test looks like when we are trying to decode it:

// show(1, ());
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Unit, mutable: true }, Unit] }):
  args[0] = Single(1)
(1, <<mutable ref>>, ())

// show(2, 123);
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Field, mutable: true }, Field] }):
  args[0] = Single(2)
  args[1] = Single(32975)
  args[2] = Single(123)
(2, <<mutable ref>>, 0x7b)

// show(3, [1, 2, 3]);
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Array { length: 3, typ: Field }, mutable: true }, Array { length: 3, typ: Field }] }):
  args[0] = Single(3)
  args[1] = Single(33121)
  args[2] = Array([1, 2, 3])
(3, <<mutable ref>>, [0x01, 0x02, 0x03])

// show(4, (1, 2, 3));
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Tuple { types: [Field, Field, Field] }, mutable: true }, Tuple { types: [Field, Field, Field] }] }):
  args[0] = Single(4)
  args[1] = Single(33333)
  args[2] = Single(33334)
  args[3] = Single(33335)
  args[4] = Single(1)
  args[5] = Single(2)
  args[6] = Single(3)
(4, <<mutable ref>>, (0x01, 0x02, 0x03))

// show(5, [(1, 2), (3, 4)]);
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Array { length: 2, typ: Tuple { types: [Field, Field] } }, mutable: true }, Array { length: 2, typ: Tuple { types: [Field, Field] } }] }):
  args[0] = Single(5)
  args[1] = Single(33604)
  args[2] = Array([1, 2, 3, 4])
(5, <<mutable ref>>, [(0x01, 0x02), (0x03, 0x04)])

// show(6, ((1, 2), [3]));
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Tuple { types: [Tuple { types: [Field, Field] }, Array { length: 1, typ: Field }] }, mutable: true }, Tuple { types: [Tuple { types: [Field, Field] }, Array { length: 1, typ: Field }] }] }):
  args[0] = Single(6)
  args[1] = Single(33906)
  args[2] = Single(33907)
  args[3] = Single(33908)
  args[4] = Single(1)
  args[5] = Single(2)
  args[6] = Array([3])
(6, <<mutable ref>>, ((0x01, 0x02), [0x03]))

// show(7, "123");
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: String { length: 3 }, mutable: true }, String { length: 3 }] }):
  args[0] = Single(7)
  args[1] = Single(34300)
  args[2] = Array([49, 50, 51])
(7, <<mutable ref>>, 123)

// show(8, (&mut (1, 2), 3));
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Tuple { types: [Reference { typ: Tuple { types: [Field, Field] }, mutable: true }, Field] }, mutable: true }, Tuple { types: [Reference { typ: Tuple { types: [Field, Field] }, mutable: true }, Field] }] }):
  args[0] = Single(8)
  args[1] = Single(34468)
  args[2] = Single(34469)
  args[3] = Single(34470)
  args[4] = Single(34466)
  args[5] = Single(34467)
  args[6] = Single(3)
(8, <<mutable ref>>, (<<mutable ref>>, 0x03))

// show(9, &[1, 2, 3]);
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Slice { typ: Field }, mutable: true }, Slice { typ: Field }] }):
  args[0] = Single(9)
  args[1] = Single(34878)
  args[2] = Single(34879)
  args[3] = Single(3)
  args[4] = Array([1, 2, 3])
(9, <<mutable ref>>, &[0x01, 0x02, 0x03])

// show(9, &[(1, 2), (3, 4)]);
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Slice { typ: Tuple { types: [Field, Field] } }, mutable: true }, Slice { typ: Tuple { types: [Field, Field] } }] }):
  args[0] = Single(9)
  args[1] = Single(35076)
  args[2] = Single(35077)
  args[3] = Single(2)
  args[4] = Array([1, 2, 3, 4])
(9, <<mutable ref>>, &[(0x01, 0x02), (0x03, 0x04)])

// show(10, Foo { a: 1, b: (true, [3, 4]), c: [5, 6, 7] });
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Struct { name: "Foo", fields: [("a", UnsignedInteger { width: 32 }), ("b", Tuple { types: [Boolean, Array { length: 2, typ: UnsignedInteger { width: 64 } }] }), ("c", Array { length: 3, typ: UnsignedInteger { width: 64 } })] }, mutable: true }, Struct { name: "Foo", fields: [("a", UnsignedInteger { width: 32 }), ("b", Tuple { types: [Boolean, Array { length: 2, typ: UnsignedInteger { width: 64 } }] }), ("c", Array { length: 3, typ: UnsignedInteger { width: 64 } })] }] }):
  args[0] = Single(10)
  args[1] = Single(35362)
  args[2] = Single(35363)
  args[3] = Single(35364)
  args[4] = Single(35365)
  args[5] = Single(1)
  args[6] = Single(1)
  args[7] = Array([3, 4])
  args[8] = Array([5, 6, 7])
(10, <<mutable ref>>, Foo { a: 1, b: (true, [3, 4]), c: [5, 6, 7] })

// show(11, Bar::Baz((1, [2, 3])));
convert_string_inputs(Tuple { types: [UnsignedInteger { width: 32 }, Reference { typ: Enum { name: "Bar", variants: [("Baz", [Tuple { types: [UnsignedInteger { width: 32 }, Array { length: 2, typ: UnsignedInteger { width: 32 } }] }])] }, mutable: true }, Enum { name: "Bar", variants: [("Baz", [Tuple { types: [UnsignedInteger { width: 32 }, Array { length: 2, typ: UnsignedInteger { width: 32 } }] }])] }] }):
  args[0] = Single(11)
  args[1] = Single(36056)
  args[2] = Single(36057)
  args[3] = Single(36058)
  args[4] = Single(0)
  args[5] = Single(1)
  args[6] = Array([2, 3])
The application panicked (crashed).
Message:  not yet implemented: enum ref length

Documentation*

Check one:

• No documentation needed.
• Documentation included in this PR.
• [For Experimental Features] Documentation to be submitted in a separate PR.

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[github-actions]

⚠️ Performance Alert ⚠️

Possible performance regression was detected for benchmark 'Test Suite Duration'.
Benchmark result of this commit is worse than the previous benchmark result exceeding threshold 1.20.

Benchmark suite	Current: dc09203	Previous: 4451b45	Ratio
test_report_zkpassport_noir-ecdsa_	3 s	1 s	3

This comment was automatically generated by workflow using github-action-benchmark.

CC: @TomAFrench

[asterite]

Looks great!