diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs index 66ed997f470..f13ffe23d33 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs @@ -403,36 +403,17 @@ impl BrilligContext< /// Initializes an array, allocating memory to store its representation and initializing the reference counter. pub(crate) fn codegen_initialize_array(&mut self, array: BrilligArray) { self.codegen_allocate_immediate_mem(array.pointer, array.size + 1); - self.indirect_const_instruction( - array.pointer, - BRILLIG_MEMORY_ADDRESSING_BIT_SIZE, - 1_usize.into(), - ); + self.initialize_rc(array.pointer, 1); } - pub(crate) fn codegen_initialize_vector_metadata( - &mut self, - vector: BrilligVector, - size: SingleAddrVariable, - capacity: Option, - ) { - // Write RC + /// Initialize the reference counter for an array or vector. + /// This should only be used internally in the array and vector initialization methods + fn initialize_rc(&mut self, pointer: MemoryAddress, rc_value: usize) { self.indirect_const_instruction( - vector.pointer, + pointer, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE, - 1_usize.into(), + rc_value.into(), ); - - // Write size - let write_pointer = self.allocate_register(); - self.codegen_usize_op(vector.pointer, write_pointer, BrilligBinaryOp::Add, 1); - self.store_instruction(write_pointer, size.address); - - // Write capacity - self.codegen_usize_op_in_place(write_pointer, BrilligBinaryOp::Add, 1); - self.store_instruction(write_pointer, capacity.unwrap_or(size).address); - - self.deallocate_register(write_pointer); } /// Initializes a vector, allocating memory to store its representation and initializing the reference counter, size and capacity @@ -456,6 +437,28 @@ impl BrilligContext< self.codegen_initialize_vector_metadata(vector, size, capacity); } + /// Writes vector metadata (reference count, size, and capacity) into the allocated memory + pub(super) fn codegen_initialize_vector_metadata( + &mut self, + vector: BrilligVector, + size: SingleAddrVariable, + capacity: Option, + ) { + // Write RC + self.initialize_rc(vector.pointer, 1); + + // Write size + let write_pointer = self.allocate_register(); + self.codegen_usize_op(vector.pointer, write_pointer, BrilligBinaryOp::Add, 1); + self.store_instruction(write_pointer, size.address); + + // Write capacity + self.codegen_usize_op_in_place(write_pointer, BrilligBinaryOp::Add, 1); + self.store_instruction(write_pointer, capacity.unwrap_or(size).address); + + self.deallocate_register(write_pointer); + } + /// We don't know the length of a vector returned externally before the call /// so we pass the free memory pointer and then use this function to allocate /// after the fact when we know the length. diff --git a/compiler/noirc_frontend/src/ownership/mod.rs b/compiler/noirc_frontend/src/ownership/mod.rs index 09446a59440..1cf8dbb9f6f 100644 --- a/compiler/noirc_frontend/src/ownership/mod.rs +++ b/compiler/noirc_frontend/src/ownership/mod.rs @@ -204,12 +204,14 @@ impl Context { /// Whenever an ident is used it is always cloned unless it is the last use of the ident (not in a loop). fn should_clone_ident(&self, ident: &Ident) -> bool { - if let Definition::Local(local_id) = &ident.definition { - if contains_array_or_str_type(&ident.typ) && !self.should_move(*local_id, ident.id) { - return true; + match &ident.definition { + Definition::Local(local_id) => { + contains_array_or_str_type(&ident.typ) && !self.should_move(*local_id, ident.id) } + // Globals are always cloned if they contain arrays + Definition::Global(_) => contains_array_or_str_type(&ident.typ), + _ => false, } - false } fn handle_ident(&self, expr: &mut Expression) { diff --git a/test_programs/execution_success/global_array_rc_regression_8259/Nargo.toml b/test_programs/execution_success/global_array_rc_regression_8259/Nargo.toml new file mode 100644 index 00000000000..a34d4dedfa1 --- /dev/null +++ b/test_programs/execution_success/global_array_rc_regression_8259/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "global_array_rc_regression_8259" +type = "bin" +authors = [""] + +[dependencies] \ No newline at end of file diff --git a/test_programs/execution_success/global_array_rc_regression_8259/Prover.toml b/test_programs/execution_success/global_array_rc_regression_8259/Prover.toml new file mode 100644 index 00000000000..f790ee45c90 --- /dev/null +++ b/test_programs/execution_success/global_array_rc_regression_8259/Prover.toml @@ -0,0 +1 @@ +a = true diff --git a/test_programs/execution_success/global_array_rc_regression_8259/src/main.nr b/test_programs/execution_success/global_array_rc_regression_8259/src/main.nr new file mode 100644 index 00000000000..8ae89994ba3 --- /dev/null +++ b/test_programs/execution_success/global_array_rc_regression_8259/src/main.nr @@ -0,0 +1,13 @@ +global G_C: [bool; 3] = [true, false, true]; +fn main(a: bool) -> pub [bool; 3] { + let b = func_1(a, G_C); + if a { + G_C + } else { + b + } +} +fn func_1(a: bool, mut b: [bool; 3]) -> [bool; 3] { + b[1] = a; + b +} diff --git a/test_programs/execution_success/global_array_rc_regression_8259/stdout.txt b/test_programs/execution_success/global_array_rc_regression_8259/stdout.txt new file mode 100644 index 00000000000..2bed83b5e66 --- /dev/null +++ b/test_programs/execution_success/global_array_rc_regression_8259/stdout.txt @@ -0,0 +1 @@ +[global_array_rc_regression_8259] Circuit output: Vec([Field(1), Field(0), Field(1)]) \ No newline at end of file diff --git a/test_programs/execution_success/global_slice_rc_regression_8259/Nargo.toml b/test_programs/execution_success/global_slice_rc_regression_8259/Nargo.toml new file mode 100644 index 00000000000..4b07a37706b --- /dev/null +++ b/test_programs/execution_success/global_slice_rc_regression_8259/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "global_slice_rc_regression_8259" +type = "bin" +authors = [""] + +[dependencies] \ No newline at end of file diff --git a/test_programs/execution_success/global_slice_rc_regression_8259/Prover.toml b/test_programs/execution_success/global_slice_rc_regression_8259/Prover.toml new file mode 100644 index 00000000000..f790ee45c90 --- /dev/null +++ b/test_programs/execution_success/global_slice_rc_regression_8259/Prover.toml @@ -0,0 +1 @@ +a = true diff --git a/test_programs/execution_success/global_slice_rc_regression_8259/src/main.nr b/test_programs/execution_success/global_slice_rc_regression_8259/src/main.nr new file mode 100644 index 00000000000..b7225422929 --- /dev/null +++ b/test_programs/execution_success/global_slice_rc_regression_8259/src/main.nr @@ -0,0 +1,9 @@ +global G_C: [bool] = &[true, false, true]; +fn main(a: bool) { + println(func_1(a, G_C)); + println(G_C); +} +fn func_1(a: bool, mut b: [bool]) -> [bool] { + b[1] = a; + b +} diff --git a/test_programs/execution_success/global_slice_rc_regression_8259/stdout.txt b/test_programs/execution_success/global_slice_rc_regression_8259/stdout.txt new file mode 100644 index 00000000000..e78acd63dc8 --- /dev/null +++ b/test_programs/execution_success/global_slice_rc_regression_8259/stdout.txt @@ -0,0 +1,2 @@ +&[true, true, true] +&[true, false, true] \ No newline at end of file diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..e35720b5d26 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,37 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "array", + "length": 3, + "type": { + "kind": "boolean" + } + }, + "visibility": "public" + }, + "error_types": {} + }, + "bytecode": "H4sIAAAAAAAA/7WSXQrEIAyEN7oHSkxSk7e9ysra+x9hC7UQfK39QHQQhskPvE7ycd7jDUND0JFLf8aN9yAIXoybSK+lE9MXizdTFG2bkZGa/ooxdxOr3ryik3CnXZ33YfZEvqvuNPmuyLoqY1rnhU/OOi/sH0w7O5PDXwo68gcSLIqtAAMAAA==", + "debug_symbols": "dY/RCoMwDEX/Jc99cIwxtl8ZQ2KNUghpia0wxH9fFN1ksKf05vRc2glaakpfB+niAPfHBI0G5tDXHD3mEMW20+xgj3VWIlvBgZuVUEky3KUwOxiRy3ppSCjrzKhGKwckrU0r7ALTcprd167+q7fz5p6q68e+mP60hD7o74NH1IAN0xa7Iv5A8yvtZP9w0uipLUpL08qs+w0=", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..e35720b5d26 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,37 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "array", + "length": 3, + "type": { + "kind": "boolean" + } + }, + "visibility": "public" + }, + "error_types": {} + }, + "bytecode": "H4sIAAAAAAAA/7WSXQrEIAyEN7oHSkxSk7e9ysra+x9hC7UQfK39QHQQhskPvE7ycd7jDUND0JFLf8aN9yAIXoybSK+lE9MXizdTFG2bkZGa/ooxdxOr3ryik3CnXZ33YfZEvqvuNPmuyLoqY1rnhU/OOi/sH0w7O5PDXwo68gcSLIqtAAMAAA==", + "debug_symbols": "dY/RCoMwDEX/Jc99cIwxtl8ZQ2KNUghpia0wxH9fFN1ksKf05vRc2glaakpfB+niAPfHBI0G5tDXHD3mEMW20+xgj3VWIlvBgZuVUEky3KUwOxiRy3ppSCjrzKhGKwckrU0r7ALTcprd167+q7fz5p6q68e+mP60hD7o74NH1IAN0xa7Iv5A8yvtZP9w0uipLUpL08qs+w0=", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..e35720b5d26 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,37 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "array", + "length": 3, + "type": { + "kind": "boolean" + } + }, + "visibility": "public" + }, + "error_types": {} + }, + "bytecode": "H4sIAAAAAAAA/7WSXQrEIAyEN7oHSkxSk7e9ysra+x9hC7UQfK39QHQQhskPvE7ycd7jDUND0JFLf8aN9yAIXoybSK+lE9MXizdTFG2bkZGa/ooxdxOr3ryik3CnXZ33YfZEvqvuNPmuyLoqY1rnhU/OOi/sH0w7O5PDXwo68gcSLIqtAAMAAA==", + "debug_symbols": "dY/RCoMwDEX/Jc99cIwxtl8ZQ2KNUghpia0wxH9fFN1ksKf05vRc2glaakpfB+niAPfHBI0G5tDXHD3mEMW20+xgj3VWIlvBgZuVUEky3KUwOxiRy3ppSCjrzKhGKwckrU0r7ALTcprd167+q7fz5p6q68e+mP60hD7o74NH1IAN0xa7Iv5A8yvtZP9w0uipLUpL08qs+w0=", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..4a2095ca975 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,53 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "array", + "length": 3, + "type": { + "kind": "boolean" + } + }, + "visibility": "public" + }, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/8VXTW/bMAylYytfXpdg2y/YbTdnTpb0FqBds8t22YCd3RTBLrsN2I766bNaEX5+VlygtVACgSyS4qNImowTeaC0/iX+OfOr7pGUt/dr8TxaDWirSMDHFJ5HsA9e6qwy6P/z68yvIwLbDxSQGeEOaX9XrI8zadPA/pcziGOs+HCCB7RfTLydL1ZaNSGEm5Ien3F04Z+x5lRnWv/eSfP8HjAQU7HYjspjxqOul0u1n0WwX1N5oXe0jf0RxM9RZtvYKDMgyyCeVxSfGPWI8YlUj+VbOV+D+i5f2UYmMnwvuo5jv9Acfvb2EUOxb2yUuK4TwhNp51AIf06+Dt3XEsJDfzA+/G4cbNfXZUDGNXII4BwCOCFb1wPaUr9yeXhvv3n+Qrp9UOMQewZor9V+kknTg/m/gt6Pe2QGfhviffCru+8POHOu7yOPY4n1yDMhUs/e6Fwz0iWVjeleKJuAPvrPlNKee/xPsMt67A/2T/VtId1ccY0ZOBejxtQXrDETuO9IunEdg9+GeJfSxIlrDO+bBnh9Ncb+ZGRb6bX053oUOBf6L6DndR5kIBtyHrg43YIfnfjatgznh+rlwJ/Y5mxK92J7jqaoT7IZyPD+juZ+r/XDttQPQ/pf/X7h1zGc0fPLAP6Y8Ft+B3iYZ7aVBniq72J6459dXGPmf7trPh419ka6/QfxDel/9/s53Vffkf0T/Txtq9WprE7Vprq7Wx+rN2QfY5ZHwK+25e74cX3c3m7Kqvz0KD7O8MhzetX37fAS/aI18wGXZ2Vfz+W5gPo8ixwt5fF5y7XgyOUq9O5jLB1p/8D+gvrqtyH9k+rWv1/gz72u7eI5vb89esmZ9d5GgJfZNi/Ud7Afq75iz23XR5XlIMM8O3rl9xgvtKV+GNL/4/eaE+yhen4ZwJ8SfsvvAI/7cR7QzwP6Lj+/1Z5f8e4xvoXGZB957JvWjqvr//bhYlbVFAAA", + "debug_symbols": "jZJLjoQgFEX3wpiBoPzcijEGFSskBA2lnXSMe++HT7uqBp30hAM+zpXfTkbXb4/Ox2l+krrZSZ98CP7RhXmwq58jfN1JkZuqJDWjpKoQAiERCqER5oQoEAzBEZgiMEVgisAUgSkCUyTqEnWJukRdoq5hJgeYE6ZAMARHlIgKAf/jx0HJvb1uTc7l3b3tF05hscnFldRxC4GSLxu2c9JzsfHkahNUC0pcHIEQOPngcu+gL7v4WzXl5bJC/dri3zpn5vI5Lz/8FkZ28OnjAo+clLztg7uG0xaHt+r6vdyV+wEsaR7cuCWXk16vAJrGaMqYaSmBs22kokpBn+WK0lSXeQB30OiKatkeeU0/", + "file_map": { + "50": { + "source": "global G_C: [bool; 3] = [true, false, true];\nfn main(a: bool) -> pub [bool; 3] {\n let b = func_1(a, G_C);\n if a {\n G_C\n } else {\n b\n }\n}\nfn func_1(a: bool, mut b: [bool; 3]) -> [bool; 3] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..07eb4f633ed --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,53 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "array", + "length": 3, + "type": { + "kind": "boolean" + } + }, + "visibility": "public" + }, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VXwW7TQBBdx3YS25REwBdw4+bilASJQyRKAze4gMQBYVJyQoJP8KfjpTPy8/O4Ra13JWt3Z2bfm52dWduRu2lx+0QyTqTXOTaV7aUvH9bOJ8QqI/AxhvEM5uamRo3B/o/0mfQzIttPFJCMeKfE35WbY+b6bWL/qwziGCo+fMAT4pcLwXnfuF5OOOKNyY7X+HYmY8w5tVm2zzPXjZ8DB3IqF+OoPmQ82nx5rfhJAPy2VWe6x6bDn0H8fEuaPjfqUtAlEM8rik+IfMT4BMrH6qkbz0Gt5bdNp3Nu+rvoMgx+qWf4TvCRQ7mvmiBx3UTE51z/DB3x5+Tr1PdaRHzoD8aHa+PQDH1dGzrOkYPBczB4LKzLCbHUr8Ld1O0nka/c8B7UOIR+B+hdq/dJ4ro7mL8VdH98Rybgd0qyF9L7/X6BNWP3Pso4lpiPmBu8Dusq4H3+X3WF/LkL+73AZ3lXXDV2qeHrmnS+YV2xLjZksxEsfL8/FAv9Wrnh/rmO0IcQdTQXvMTYB/o2I3scO9fVkcreSG/VkXXeKLutjtifhLC1PZb5AmRWPeI663tH1+s7LwHdlLXp4/QV/BjEt+nrMB/VrgD5ounWxrQvxvNtifaky0CH+/ctl7nmD2OpHynZf5T5Svo5rNH1a4N/Tvw9vw0ZnjNjxYZM7X1MP8jYxzXk+W933Q+yxj51/X9dR/wp2X+WeU771RrZ39PP07Y+P1X1qb6or683x/oJ4WPMigD89bbaHV9ujtsfF1VdvbqT38onrGffNCcxZ9Fe8VKy/6a27fNdxvyvg3ze7vctdtFI/w/DkCVNX2blMta42it33gx9VF0BOvxv8+2RzDFeiKV+pGT/S+Z6JliXun5t8C+Jv+e3IeMaLwz7wrD35/NT8aTHvYf4h5gTPsrYN80dn9d/AVkXV1gNFAAA", + "debug_symbols": "dZHBjoQgDED/hTMHqiOCv2KMQcUJCUHD6CYb479vsbozHubCo5TXFLqxwXbrs3VhnF6sqjfWRee9e7Z+6s3ipoCnGxNpeeSsyjh7PAgFQRJKgiLoA4UgACEjUJUCqwCiIEhCSVAEfUAKAhByAumSdEm6TPq+c3b13i7R2tT6x2PwibOJNiysCqv3nP0Yvx6XXrMJBxcTMSs4s2FAYsHReZt2O3/b4ruq89MFUf7bxV2H73oG+vSzLL/5DUamd/E2nT1Vis503p7huIb+I7v8zlfmmu4cp94Oa7Sp0nvEuNRacABoOMOfrkvBlcA9pIwCrmQKIAUlV7rZU09/", + "file_map": { + "50": { + "source": "global G_C: [bool; 3] = [true, false, true];\nfn main(a: bool) -> pub [bool; 3] {\n let b = func_1(a, G_C);\n if a {\n G_C\n } else {\n b\n }\n}\nfn func_1(a: bool, mut b: [bool; 3]) -> [bool; 3] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..07eb4f633ed --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_array_rc_regression_8259/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,53 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "array", + "length": 3, + "type": { + "kind": "boolean" + } + }, + "visibility": "public" + }, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VXwW7TQBBdx3YS25REwBdw4+bilASJQyRKAze4gMQBYVJyQoJP8KfjpTPy8/O4Ra13JWt3Z2bfm52dWduRu2lx+0QyTqTXOTaV7aUvH9bOJ8QqI/AxhvEM5uamRo3B/o/0mfQzIttPFJCMeKfE35WbY+b6bWL/qwziGCo+fMAT4pcLwXnfuF5OOOKNyY7X+HYmY8w5tVm2zzPXjZ8DB3IqF+OoPmQ82nx5rfhJAPy2VWe6x6bDn0H8fEuaPjfqUtAlEM8rik+IfMT4BMrH6qkbz0Gt5bdNp3Nu+rvoMgx+qWf4TvCRQ7mvmiBx3UTE51z/DB3x5+Tr1PdaRHzoD8aHa+PQDH1dGzrOkYPBczB4LKzLCbHUr8Ld1O0nka/c8B7UOIR+B+hdq/dJ4ro7mL8VdH98Rybgd0qyF9L7/X6BNWP3Pso4lpiPmBu8Dusq4H3+X3WF/LkL+73AZ3lXXDV2qeHrmnS+YV2xLjZksxEsfL8/FAv9Wrnh/rmO0IcQdTQXvMTYB/o2I3scO9fVkcreSG/VkXXeKLutjtifhLC1PZb5AmRWPeI663tH1+s7LwHdlLXp4/QV/BjEt+nrMB/VrgD5ounWxrQvxvNtifaky0CH+/ctl7nmD2OpHynZf5T5Svo5rNH1a4N/Tvw9vw0ZnjNjxYZM7X1MP8jYxzXk+W933Q+yxj51/X9dR/wp2X+WeU771RrZ39PP07Y+P1X1qb6or683x/oJ4WPMigD89bbaHV9ujtsfF1VdvbqT38onrGffNCcxZ9Fe8VKy/6a27fNdxvyvg3ze7vctdtFI/w/DkCVNX2blMta42it33gx9VF0BOvxv8+2RzDFeiKV+pGT/S+Z6JliXun5t8C+Jv+e3IeMaLwz7wrD35/NT8aTHvYf4h5gTPsrYN80dn9d/AVkXV1gNFAAA", + "debug_symbols": "dZHBjoQgDED/hTMHqiOCv2KMQcUJCUHD6CYb479vsbozHubCo5TXFLqxwXbrs3VhnF6sqjfWRee9e7Z+6s3ipoCnGxNpeeSsyjh7PAgFQRJKgiLoA4UgACEjUJUCqwCiIEhCSVAEfUAKAhByAumSdEm6TPq+c3b13i7R2tT6x2PwibOJNiysCqv3nP0Yvx6XXrMJBxcTMSs4s2FAYsHReZt2O3/b4ruq89MFUf7bxV2H73oG+vSzLL/5DUamd/E2nT1Vis503p7huIb+I7v8zlfmmu4cp94Oa7Sp0nvEuNRacABoOMOfrkvBlcA9pIwCrmQKIAUlV7rZU09/", + "file_map": { + "50": { + "source": "global G_C: [bool; 3] = [true, false, true];\nfn main(a: bool) -> pub [bool; 3] {\n let b = func_1(a, G_C);\n if a {\n G_C\n } else {\n b\n }\n}\nfn func_1(a: bool, mut b: [bool; 3]) -> [bool; 3] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..6d6e8832d92 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,44 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+2Z227TQBCG7fgUp0mTJm1p7pGQuADn0KbcRYIeXsNpiMQNQogH8MtwAy9Jg3ac35MJFHkGgpSVol17x9/8Ozve3SS+tymBq33X9uE6ZDZSmbs6q1dGhuwJje1v6PcNuEqszHrsh4SpoV+Jaz/JuDL43u8L2Xx3derqBvQHikJT5leTf51N36TC+BT1T1Ihxor8S+JHNvwscZx3xYaPYyG/AbPjz6DNDdjcFFXdZHMLNrc7OHdgc7fD5h5s7plNx7Ux70kz9TW8ba0p6EXtc3ed1SiPOXllPKdlTiZGfIppDLELhDElbB5CsPd31MTifeSr5Zm+b6NfjQ31U970mD2PwS5W/IesfzmnGGuc0582RVUP9oXQF7O+qNgeY/Px8xzs+DsYgt1raI9YjCz3ElwztNfigaAffa1LUnhlodgEcI/iSnFuoj3rS6EvLKp+Wu46BD/IIh0Rs3/lrruujuEZer4n+I+Z/4pu4R6PSyrYp4L9Og9fuPaRtznfvC2qvLmrs5pl7WOdo19Jk7f9Tvlq/mYLaW/R44/HxI9N+FcLaZ1T5JfvcNOG/574qQ1/SvyWCX+SE//IJj/Ls0nbJj4PxO/Y8Ev9xzb88rzfNeGPy/j0bOa3zM8TG375/vZt+BnxBzbzW66fpzb8FfHPbPgj4p/bxH9J575n3qaUe7xrX8B9vfPXePHU7yLkv8W0Wn0XuWB6eHzobEOxGwpae0IfP4MMBT9DwY/EihRZsSIrUWQ1FVmpIksz9q091XWkyGorsjTzq6PIOlZkac5jd0919RRZJ4qsviJrX3NCc8057GmHPe1/2dMGiqzTPWVp7rWa69eZIkvzHdLMr3NDlvQ/QSCwusK46Fnj/zTGpDUUtOJ6nDxhbNL3rTaM69PnDx+/eKxE0CY4XjcAiEKlRCBRL5kP+uGa+8J2AD64jaTLZ36oH38wD4sqf+7uZzXK7DrLyFcA48LE8pj/iNl/c9e46FMd1tC5muWj1SRf5Zf5cjl9yPuMvy4NiNMPeIRvXLclAAA=", + "debug_symbols": "tdVNboMwEAXgu7BmwdjGY/cqVRSRxK2QEIkoVKqi3L123qM/C6qqUje8EJjPjjOGa3VKh+V5349P55fq4fFaHaZ+GPrn/XA+dnN/HvO316ophzYfpa5aQRiERThEi/AIRQREvIeH4qF4KB6Kh+KheCgeiofioSgUhaJQFIpCUSgKRaEoFIUSoAQoAUqAEqAEKAFKgBKgBCgRSoQSoUQoEUqEEqFEKBFKhCJNwxSmYVqmY7ZMz1RmYNITekJP6Ak9oSf0hJ7QE3pCz9Az9Aw9Q8/QM/QMPUPP0DP0LD1Lz9Kz9Cw9S8/Ss/QsPUvP0XP0HD1Hz9Fz9Bw9R8/Rc/TY7sJ+Fza8sOOFLS/seWHTC7teStubkhFZGv+ewjTM7Jnbra7WHbefp5TKhvuyBfPGvHRTGufqYVyGoa5eu2G53/Ry6cZ7zt2UrzZ1lcZTzgw+9UMqn271Z3WzXRqisDga+1FuzG/r1SnrNTR/qmd5CB/V7ffZ2+3qvK4sF99u1f8wuvfr6HGruv2/tYvtOvlGt4bXvwy/y2fdsZ++P89zC+afmxuwrPRrN/XdYUjlSqldxuN6Yz6d3y7rlfXVcJnOx3RaplTQz/dD7uNH62vnd+UplE/yH1GLNrtbmcY7", + "file_map": { + "22": { + "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", + "path": "std/lib.nr" + }, + "50": { + "source": "global G_C: [bool] = &[true, false, true];\nfn main(a: bool) {\n println(func_1(a, G_C));\n println(G_C);\n}\nfn func_1(a: bool, mut b: [bool]) -> [bool] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "print_unconstrained" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..6d6e8832d92 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,44 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+2Z227TQBCG7fgUp0mTJm1p7pGQuADn0KbcRYIeXsNpiMQNQogH8MtwAy9Jg3ac35MJFHkGgpSVol17x9/8Ozve3SS+tymBq33X9uE6ZDZSmbs6q1dGhuwJje1v6PcNuEqszHrsh4SpoV+Jaz/JuDL43u8L2Xx3derqBvQHikJT5leTf51N36TC+BT1T1Ihxor8S+JHNvwscZx3xYaPYyG/AbPjz6DNDdjcFFXdZHMLNrc7OHdgc7fD5h5s7plNx7Ux70kz9TW8ba0p6EXtc3ed1SiPOXllPKdlTiZGfIppDLELhDElbB5CsPd31MTifeSr5Zm+b6NfjQ31U970mD2PwS5W/IesfzmnGGuc0582RVUP9oXQF7O+qNgeY/Px8xzs+DsYgt1raI9YjCz3ElwztNfigaAffa1LUnhlodgEcI/iSnFuoj3rS6EvLKp+Wu46BD/IIh0Rs3/lrruujuEZer4n+I+Z/4pu4R6PSyrYp4L9Og9fuPaRtznfvC2qvLmrs5pl7WOdo19Jk7f9Tvlq/mYLaW/R44/HxI9N+FcLaZ1T5JfvcNOG/574qQ1/SvyWCX+SE//IJj/Ls0nbJj4PxO/Y8Ev9xzb88rzfNeGPy/j0bOa3zM8TG375/vZt+BnxBzbzW66fpzb8FfHPbPgj4p/bxH9J575n3qaUe7xrX8B9vfPXePHU7yLkv8W0Wn0XuWB6eHzobEOxGwpae0IfP4MMBT9DwY/EihRZsSIrUWQ1FVmpIksz9q091XWkyGorsjTzq6PIOlZkac5jd0919RRZJ4qsviJrX3NCc8057GmHPe1/2dMGiqzTPWVp7rWa69eZIkvzHdLMr3NDlvQ/QSCwusK46Fnj/zTGpDUUtOJ6nDxhbNL3rTaM69PnDx+/eKxE0CY4XjcAiEKlRCBRL5kP+uGa+8J2AD64jaTLZ36oH38wD4sqf+7uZzXK7DrLyFcA48LE8pj/iNl/c9e46FMd1tC5muWj1SRf5Zf5cjl9yPuMvy4NiNMPeIRvXLclAAA=", + "debug_symbols": "tdVNboMwEAXgu7BmwdjGY/cqVRSRxK2QEIkoVKqi3L123qM/C6qqUje8EJjPjjOGa3VKh+V5349P55fq4fFaHaZ+GPrn/XA+dnN/HvO316ophzYfpa5aQRiERThEi/AIRQREvIeH4qF4KB6Kh+KheCgeiofioSgUhaJQFIpCUSgKRaEoFIUSoAQoAUqAEqAEKAFKgBKgBCgRSoQSoUQoEUqEEqFEKBFKhCJNwxSmYVqmY7ZMz1RmYNITekJP6Ak9oSf0hJ7QE3pCz9Az9Aw9Q8/QM/QMPUPP0DP0LD1Lz9Kz9Cw9S8/Ss/QsPUvP0XP0HD1Hz9Fz9Bw9R8/Rc/TY7sJ+Fza8sOOFLS/seWHTC7teStubkhFZGv+ewjTM7Jnbra7WHbefp5TKhvuyBfPGvHRTGufqYVyGoa5eu2G53/Ry6cZ7zt2UrzZ1lcZTzgw+9UMqn271Z3WzXRqisDga+1FuzG/r1SnrNTR/qmd5CB/V7ffZ2+3qvK4sF99u1f8wuvfr6HGruv2/tYvtOvlGt4bXvwy/y2fdsZ++P89zC+afmxuwrPRrN/XdYUjlSqldxuN6Yz6d3y7rlfXVcJnOx3RaplTQz/dD7uNH62vnd+UplE/yH1GLNrtbmcY7", + "file_map": { + "22": { + "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", + "path": "std/lib.nr" + }, + "50": { + "source": "global G_C: [bool] = &[true, false, true];\nfn main(a: bool) {\n println(func_1(a, G_C));\n println(G_C);\n}\nfn func_1(a: bool, mut b: [bool]) -> [bool] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "print_unconstrained" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..6d6e8832d92 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,44 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+2Z227TQBCG7fgUp0mTJm1p7pGQuADn0KbcRYIeXsNpiMQNQogH8MtwAy9Jg3ac35MJFHkGgpSVol17x9/8Ozve3SS+tymBq33X9uE6ZDZSmbs6q1dGhuwJje1v6PcNuEqszHrsh4SpoV+Jaz/JuDL43u8L2Xx3derqBvQHikJT5leTf51N36TC+BT1T1Ihxor8S+JHNvwscZx3xYaPYyG/AbPjz6DNDdjcFFXdZHMLNrc7OHdgc7fD5h5s7plNx7Ux70kz9TW8ba0p6EXtc3ed1SiPOXllPKdlTiZGfIppDLELhDElbB5CsPd31MTifeSr5Zm+b6NfjQ31U970mD2PwS5W/IesfzmnGGuc0582RVUP9oXQF7O+qNgeY/Px8xzs+DsYgt1raI9YjCz3ElwztNfigaAffa1LUnhlodgEcI/iSnFuoj3rS6EvLKp+Wu46BD/IIh0Rs3/lrruujuEZer4n+I+Z/4pu4R6PSyrYp4L9Og9fuPaRtznfvC2qvLmrs5pl7WOdo19Jk7f9Tvlq/mYLaW/R44/HxI9N+FcLaZ1T5JfvcNOG/574qQ1/SvyWCX+SE//IJj/Ls0nbJj4PxO/Y8Ev9xzb88rzfNeGPy/j0bOa3zM8TG375/vZt+BnxBzbzW66fpzb8FfHPbPgj4p/bxH9J575n3qaUe7xrX8B9vfPXePHU7yLkv8W0Wn0XuWB6eHzobEOxGwpae0IfP4MMBT9DwY/EihRZsSIrUWQ1FVmpIksz9q091XWkyGorsjTzq6PIOlZkac5jd0919RRZJ4qsviJrX3NCc8057GmHPe1/2dMGiqzTPWVp7rWa69eZIkvzHdLMr3NDlvQ/QSCwusK46Fnj/zTGpDUUtOJ6nDxhbNL3rTaM69PnDx+/eKxE0CY4XjcAiEKlRCBRL5kP+uGa+8J2AD64jaTLZ36oH38wD4sqf+7uZzXK7DrLyFcA48LE8pj/iNl/c9e46FMd1tC5muWj1SRf5Zf5cjl9yPuMvy4NiNMPeIRvXLclAAA=", + "debug_symbols": "tdVNboMwEAXgu7BmwdjGY/cqVRSRxK2QEIkoVKqi3L123qM/C6qqUje8EJjPjjOGa3VKh+V5349P55fq4fFaHaZ+GPrn/XA+dnN/HvO316ophzYfpa5aQRiERThEi/AIRQREvIeH4qF4KB6Kh+KheCgeiofioSgUhaJQFIpCUSgKRaEoFIUSoAQoAUqAEqAEKAFKgBKgBCgRSoQSoUQoEUqEEqFEKBFKhCJNwxSmYVqmY7ZMz1RmYNITekJP6Ak9oSf0hJ7QE3pCz9Az9Aw9Q8/QM/QMPUPP0DP0LD1Lz9Kz9Cw9S8/Ss/QsPUvP0XP0HD1Hz9Fz9Bw9R8/Rc/TY7sJ+Fza8sOOFLS/seWHTC7teStubkhFZGv+ewjTM7Jnbra7WHbefp5TKhvuyBfPGvHRTGufqYVyGoa5eu2G53/Ry6cZ7zt2UrzZ1lcZTzgw+9UMqn271Z3WzXRqisDga+1FuzG/r1SnrNTR/qmd5CB/V7ffZ2+3qvK4sF99u1f8wuvfr6HGruv2/tYvtOvlGt4bXvwy/y2fdsZ++P89zC+afmxuwrPRrN/XdYUjlSqldxuN6Yz6d3y7rlfXVcJnOx3RaplTQz/dD7uNH62vnd+UplE/yH1GLNrtbmcY7", + "file_map": { + "22": { + "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", + "path": "std/lib.nr" + }, + "50": { + "source": "global G_C: [bool] = &[true, false, true];\nfn main(a: bool) {\n println(func_1(a, G_C));\n println(G_C);\n}\nfn func_1(a: bool, mut b: [bool]) -> [bool] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "print_unconstrained" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..eb28a745f5f --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,52 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "14225679739041873922": { + "error_kind": "string", + "string": "Index out of bounds" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1ZO28TQRBev3I+P2LnSVLTpXJ8foQuEoYEGhqQaCjOToxoEEL8gPufSBSImg5BSS7Z8X2ZG9sxmZGMlJGsvd2Z/eaxM7vru4LLqODbMus7QebUt5370bEiVkc0dBGRzB/fhr4tAr+k6GzI9Grin3R641DwT9H+KPSYlvEhTAP8TuBxXiYZPvfFQUtyfE5KTf+MeUYyVc+n58f+OWRzLNbfcH06O4L9RfAtpadJxnNOv3ZGNvgdwn+WmMQuIvwzY/wXRvgU73OP71xWJ2cwRvop/58DrzCnRSwcI101hqW97yzyDe2nXG8L8riu87DOV8QKGc9qTc+W+E36m6yPcyU/+F5wn5iMFLHIrrq72Z9f+fGWu72npURxsD6baF+ly1fZ43OdRfAP5fE5pQobO/Jt6u8bmMP9LQljPJZYh7j/F7xeg/gM6LzdcHkiXsD8Ql4V5GmPJx7em9A3TiXWR39T/Legk8txW/GMDhgP15Tstrw7XFG/yfxxgs0Ye6ohKfZFNq8KvEV/LqT4klyK8R5wuRxRy+XvZbyGre5Hi2q4KPi0ag2PIBa8hvlZyscW1TDJGedYj+c3kpR/PMcw/3gNB8BbtYZXzbH03KA9o5xkfK1YDU9ucunaXo9fcXnbUX+Fyb/2/Rqzn+J/+o92Tofx8TSKp3E/vrjoTeJthp9SEeKkrT8eRieTbm8yHPejOBos1Y/ne+jy9aZ9j8QcpjXjOovAR/l3vk1t/uqfKQ9pXclmkvsGcrx+ysltvwMbvyPyG+uz5PL3AX4+B4L8BshQzNpu+fmO+cXPH9x7yZ675EZBLUbDsXQ/0sPvdkMhfnr4g3E4Zw2U8J8QftUG/5LwQxv8HuHXTPCjmPDrNvk5e7fXsInPhPCbNvgz+zdt8PuE3zLB787i07ZZ31l+btngz+p32wa/Q/g7Nus72z93bfCnhL9ngz97d75vE/8LOksfuYz4/4YDGNe7X3THBabPufz7QtRfY7Za3fMOmD08PvwecijY2hZ4/A5yKOg5FPRIWBVFrA1FrEARq6qIFSpiaca+tqZ21RWxGopYmvnVVMTaVMTSXMfWmtrVVsTaUsTaVsRa15zQ3HMezrSHM+1/OdN2FLF21xRL86zV3L/2FLE0a0gzv/YNsaR3sCUBqyX4RXON3xd3ydayYCvux8EdfJP+bzXAr0+fP3z84hjhS3ICx/6ij+yVOUYdMR2jRNaFzyXQwWUkuwpMD/EtPrRM+oPxpNePO5fH14u27EMLXSArScbHjxYpbfg+fRjl8vhhBOW/U//q98M/06W8nOT1pXK//RgdflWwRTuZUwrQDmYP6m8J8vRsbGu0yNZAsFWKcWFOi1g4FiS3x8IkL49xCpjuGsozXh14Zaan4fuYa4hFdlSY/C/fp3Wqwhya3xb045pxXZJ+/CjFsUrCGMmnuf2T8HxbTjIszRddWEdpjf8FF6zd0y4uAAA=", + "debug_symbols": "tdXdaqtAFEDhd/HaC2fPz57pq5RSbGqLICbY5MCh5N3P6F5J24tA6aE3WTG6PyUw43vzPDydXh/H+WX/1tzdvzdPyzhN4+vjtN/1x3E/11/fm279CKG5c20ToiVZ1JItZUvsLM4iFm+piq+JlmRRS7aULamzOEtVpMZbgiVakkUt2VK2aFVijbOIxVuCJVqSRbfkOp7apnQWZxFLHdeaYImWZFFLtpQtrquX5rWRJqo002J1HXVUqKd4Ds/hOTyH5/AET/AET/AET/AET/AET/A8nsfzeB7P43k8j+fxPJ7HC3gBL+AFvIAX8AJewAt4AS/iRbyIF/EiXsSLeBEv4kW8hJfwEl7CS3gJL+ElvISX8BRP8RRP8RRP8RRP8RRP8TJexst4GS/jZbyMl/EyXsYreAWv4BW8glfwCl7BK3jFPOk66qhQTwONNFGlmeKxPoT1Iev6KGs9DTTSRKtXzue2uWxvj8dlGNbd7dN+V3fBQ78M87G5m0/T1DZ/+um0XfR26Oetx36pZ7u2Gebn2gq+jNOwfju3H9Pd7VENzOZ8HY7fnk7pMl1uTcvt6Vwc40X8dV7ku3cvkfG6fd26ffi929dFd7l/Cj/48+oivs7HH8z/7/NrUOY1d1/mH+pRvxuXLy/f8yotY/80DRy+nObdp7PHv4fLmcvL+7Dsd8PzaRlW6eMNXhfJvYi0EvRhfdnUQy1tDutBXUj3ObZZH87rg/wD", + "file_map": { + "22": { + "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", + "path": "std/lib.nr" + }, + "50": { + "source": "global G_C: [bool] = &[true, false, true];\nfn main(a: bool) {\n println(func_1(a, G_C));\n println(G_C);\n}\nfn func_1(a: bool, mut b: [bool]) -> [bool] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..34f7c01d7e7 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,48 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+2ZzW7aQBCA12AHzE9MIGm495aTY0OgN6SSkvYtDBSpl6qq+gB+qh577aWV+kiVlR17MhmbIM80VMpc1t5df/Ozu7ML65hCHFu65N0wfRa2DOvJtSArZA2tEujzx5a+LRuovSnorE/0SvLn4WTtM/4J2h/7lqkZH2Aq8MOW5XxICz71xaAS+tFvMunbZzzPoE/btsPza/vsk280xl9xfMIRY38D+ZbJ27RoM0Z+7Sx1+CHwb1OV2MXAXynz3yvxId53lm9MsU5WqA70w/x/h9qckhKzcB3o6hCWdN6p8g3bD3N9wPTH41rGujuQ5ZM2rTFd7fEb9PfJO/6W84PmgjoxWQqywK6uuc/PP219YB7mtEwgDtp7E+RVOHy5lk91NpB/uD9+zsQjdVe2zPz9jb6h/jaZOhpLvA5x/qf2aJw9TpT4EAuPiQX2CfT3mTgdkt+wro7RPVdV+VY2zrg/jUEZyzuQ5TNtGmPqVviN9fcrbKV+ZILzW92YOEaGhe3yS9gL+x7WktmaW/Ny/CjyS+Ikw79ZczlFkP8G+C0d/kfgt3X4E+D7Kvw4AX5HZ37me0ZXJz4b4Pd0+Ln9fR3+FPinKvwoj0+gM775/Bzo8PP1e6bDD4E/1BnfPH+OdPg74J/r8PP/gy504r+F/f6VKQT2StB9ierlzibR2iH6jOHPiKC/Q2zVOiNeEntofODcAbEbM7YOmDZ6BhkzesaMHo7lCrI8QdaJIKslyGoLsiRj7x+pXR1BVleQJTm/eoKsviBLchxPj9SuQJA1EGSdCbKOdU5I5pyXPe1lT/tf9rShIGt0pCzJvVYyf50LsiTXkOT8ulBkPfV/64DxC75Vvj+IHGQvtRXn45Mn+Mb93uqhvl++fvr8zRDxyDv8CQxymxZAbCg3EYB1RZjL9LEuhzw3kQ7ax2HqHaIH2gOmP72MU7owqbyMazC+HHoZ992W3GUcN4FwXdVlXFns8KRSvqgL6RzCsaPzDPyhi8RjYgd1P4xM7HBMaKzwQgVWJhBrzApM+SLnLgD+VdLBiaa1x7dnSTpeiVHPmXSyEwSc4Nz0IX9h68MaMpvfL5BMmsivpnksLmrH/X/Zd/wvBZRuDTt3s+R6Fye7ZJpst5NNMiT8TBooTtL6k1k830STzWw9jZP4Zq/+v6a0+5W7KgAA", + "debug_symbols": "tdXLbuowFIXhd8mYgbft7QuvUiEUIFSRooBSONIR4t2PnbXSlkE6Oeqkv9N0f2kgl0dz6g73930/ni8fzfbt0Rymfhj69/1wOba3/jKW3z4aU39432ztpvGKBCQiCclz1CCCWMQhUBSKQlEoCkWhBCgBSiiKljjEI4oEJCIJyXOiQQSBEqFEKBFKhBKhRCgRSoKSoCQoCUqCkqAkKAlKgpKgZCgZSoaSoWQoGUqGkqFkKBmKGMMKa1nHelbZwEY2sfSEntATekJP6Ak9oSf0hJ7Qs/QsPUvP0rP0LD1Lz9Kz9Cw9R8/Rc/QcPUfP0XP0HD1Hz9Hz9Dw9T8/T8/Q8PU/P0/P0PD2lp/SUntJTekpP6Sk9paf0Ar1Aj5e+8NoXXvzCq194+Quvf+ENILwDpN4CoVZYyzrWs8oWz9VGNrEZrTfDXGEt69ji5VplAxvZxGa03hZzhS2emLpwy8IvC10WYVnEung+N83yxNrfpq6rD6xvj7DyYLu2Uzfemu14H4ZN86cd7vMffVzbce6tncreQnbjqbSA537o6uq5+Zo266PRczalz2F9nZb16fJtc7x8r2vzPxw9hOXoeW3arU+nvBw9W/c5b+3LvP+9+egj52Mya/M/nH3W5cMzce3043/+++n35tdPf1e22mM/vbyPn1Wa+vYwdNw838fjt723v9dlz/I+v06XY3e6T12Vvl7q9dn/JjlvrPG7+gwvm9Zo2Yy7Zz38Pw==", + "file_map": { + "22": { + "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", + "path": "std/lib.nr" + }, + "50": { + "source": "global G_C: [bool] = &[true, false, true];\nfn main(a: bool) {\n println(func_1(a, G_C));\n println(G_C);\n}\nfn func_1(a: bool, mut b: [bool]) -> [bool] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..34f7c01d7e7 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/global_slice_rc_regression_8259/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,48 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "a", + "type": { + "kind": "boolean" + }, + "visibility": "private" + } + ], + "return_type": null, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+2ZzW7aQBCA12AHzE9MIGm495aTY0OgN6SSkvYtDBSpl6qq+gB+qh577aWV+kiVlR17MhmbIM80VMpc1t5df/Ozu7ML65hCHFu65N0wfRa2DOvJtSArZA2tEujzx5a+LRuovSnorE/0SvLn4WTtM/4J2h/7lqkZH2Aq8MOW5XxICz71xaAS+tFvMunbZzzPoE/btsPza/vsk280xl9xfMIRY38D+ZbJ27RoM0Z+7Sx1+CHwb1OV2MXAXynz3yvxId53lm9MsU5WqA70w/x/h9qckhKzcB3o6hCWdN6p8g3bD3N9wPTH41rGujuQ5ZM2rTFd7fEb9PfJO/6W84PmgjoxWQqywK6uuc/PP219YB7mtEwgDtp7E+RVOHy5lk91NpB/uD9+zsQjdVe2zPz9jb6h/jaZOhpLvA5x/qf2aJw9TpT4EAuPiQX2CfT3mTgdkt+wro7RPVdV+VY2zrg/jUEZyzuQ5TNtGmPqVviN9fcrbKV+ZILzW92YOEaGhe3yS9gL+x7WktmaW/Ny/CjyS+Ikw79ZczlFkP8G+C0d/kfgt3X4E+D7Kvw4AX5HZ37me0ZXJz4b4Pd0+Ln9fR3+FPinKvwoj0+gM775/Bzo8PP1e6bDD4E/1BnfPH+OdPg74J/r8PP/gy504r+F/f6VKQT2StB9ierlzibR2iH6jOHPiKC/Q2zVOiNeEntofODcAbEbM7YOmDZ6BhkzesaMHo7lCrI8QdaJIKslyGoLsiRj7x+pXR1BVleQJTm/eoKsviBLchxPj9SuQJA1EGSdCbKOdU5I5pyXPe1lT/tf9rShIGt0pCzJvVYyf50LsiTXkOT8ulBkPfV/64DxC75Vvj+IHGQvtRXn45Mn+Mb93uqhvl++fvr8zRDxyDv8CQxymxZAbCg3EYB1RZjL9LEuhzw3kQ7ax2HqHaIH2gOmP72MU7owqbyMazC+HHoZ992W3GUcN4FwXdVlXFns8KRSvqgL6RzCsaPzDPyhi8RjYgd1P4xM7HBMaKzwQgVWJhBrzApM+SLnLgD+VdLBiaa1x7dnSTpeiVHPmXSyEwSc4Nz0IX9h68MaMpvfL5BMmsivpnksLmrH/X/Zd/wvBZRuDTt3s+R6Fye7ZJpst5NNMiT8TBooTtL6k1k830STzWw9jZP4Zq/+v6a0+5W7KgAA", + "debug_symbols": "tdXLbuowFIXhd8mYgbft7QuvUiEUIFSRooBSONIR4t2PnbXSlkE6Oeqkv9N0f2kgl0dz6g73930/ni8fzfbt0Rymfhj69/1wOba3/jKW3z4aU39432ztpvGKBCQiCclz1CCCWMQhUBSKQlEoCkWhBCgBSiiKljjEI4oEJCIJyXOiQQSBEqFEKBFKhBKhRCgRSoKSoCQoCUqCkqAkKAlKgpKgZCgZSoaSoWQoGUqGkqFkKBmKGMMKa1nHelbZwEY2sfSEntATekJP6Ak9oSf0hJ7Qs/QsPUvP0rP0LD1Lz9Kz9Cw9R8/Rc/QcPUfP0XP0HD1Hz9Hz9Dw9T8/T8/Q8PU/P0/P0PD2lp/SUntJTekpP6Sk9paf0Ar1Aj5e+8NoXXvzCq194+Quvf+ENILwDpN4CoVZYyzrWs8oWz9VGNrEZrTfDXGEt69ji5VplAxvZxGa03hZzhS2emLpwy8IvC10WYVnEung+N83yxNrfpq6rD6xvj7DyYLu2Uzfemu14H4ZN86cd7vMffVzbce6tncreQnbjqbSA537o6uq5+Zo266PRczalz2F9nZb16fJtc7x8r2vzPxw9hOXoeW3arU+nvBw9W/c5b+3LvP+9+egj52Mya/M/nH3W5cMzce3043/+++n35tdPf1e22mM/vbyPn1Wa+vYwdNw838fjt723v9dlz/I+v06XY3e6T12Vvl7q9dn/JjlvrPG7+gwvm9Zo2Yy7Zz38Pw==", + "file_map": { + "22": { + "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", + "path": "std/lib.nr" + }, + "50": { + "source": "global G_C: [bool] = &[true, false, true];\nfn main(a: bool) {\n println(func_1(a, G_C));\n println(G_C);\n}\nfn func_1(a: bool, mut b: [bool]) -> [bool] {\n b[1] = a;\n b\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index c4414386370..7c21aebb8c6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -43,14 +43,18 @@ expression: artifact "visibility": "public" }, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "H4sIAAAAAAAA/+1ZzW7TQBBex3YSO0lrwYs4ddKWWyUKFCj0V0Li5v49xx55Ay5wQFy4IcEL4qU7yefxuIqopyhSV7Ic78zOfDP77XrWCcxtG1dX4H9H/t7zd9ffN/VGunv+nt+vTTu0lWthDNYAY28NMIZrgDFaA4yxAkYNnP0OcQaAkfakQXUNqyuprrS6RuZ2P1sIMTC3QBwB3QTHpr6xrWQQEvTb3xN/xw2zQ5JPE+a3S/u7+fwiMfXWMf4iAZsK9nfIfqRjPycOvbd1+4b5DZkeH4PjjkDnqEXnGHSOW3ROQOekRecUdE5bdM5A56xF5xx0zkHHtQT0jemao7Nr5TnemrBYpdhiHd9FwPwZU+eXYf5To7qepgHzR3h4fnosPwMdPDnZHyrZp3gTIV7M/4DFO9LBUxAXU8DDuTjW8T1blYvkP2VYtbg4FuYG80NcnJCOXeJJmCyyzThIFoOM5tfx7gPEhzLEg/sDcTUzTa4QbuV1Uyivm+njulm0x3UDMu11MzFyrYGyHvihWsXZvgBsnxi2noAN55O/7zTev1U9PleuNxbv076SfcrbUMgnnpEovk3T3AeHbG4kWwNhbu7ak3C+KHblPSlX3ncWud4Q4sUcjliuJyDbYLmTbE3uyPWmoI9n1jHLdaaTi0LawygWaQ/bZDLcwwgj7mHKXJkqc6V45MoyFw/FFY1vQviOUDoDbj9twU+/XRtYs2ghyyfmiHI2RH0mS0AW2bqf1D9H4AdtEY6Y6Zf+meauD2NofCb47zP/NdxCH+aI2wqFPtJ376CP/rdbc7QOntulPXft+f78Xm12Sfb3dexfk/0XKvbn28SVl3aZS6zvXXsFvh+6vkf/KcOqUd+jP8SD+eH1/YFtYs0EGXKQy0Khj/xItvY7tEXckua7Q66VCfPd8Vp5RvZf69jfpfl+Y5e542vlLfj+H2uF/KcMq9ZaIX+IB/PD18qhbWLNBBlykMtCoY/zG2UHHdoiblE8GD/nwiH4fehv2+g/ZVi1uCDlFfPDufDONrFmggz3ey4LhT4+fygjbrrawNWWn2EMr8fw28WGqZ+vXcN8BsI4qR6m8cSRCGRdcsTF9hVwOPsRYMc6EvEbU+exVr1dta1VeIz+U9PMtcb3vVW/WfH/t3BsJsgo/1iXRrb7WHZ2l3/qE/diwIItAjnqf/HP+C0V49j7R5w3O+X0pihvynl5dTW7LJ8w+wZy6PIknTNwPblGZxU8y6A+2YuZ/jfSra7v/jc/i6I/p/frDr2g5f7XhtAX2XqfdMbBsx/pk+/UNjGSbAQyPFe7NvbPmC+0RThipv/TP9Oc4HmNxmeC/yHzX8Mt9PGz30jQHwn6bn5+kD1/x9g13nl9Zh/7ODbijuP1H+YZ//olKAAA", - "debug_symbols": "XY7dCoMwDIXfJde9WBmuzlcRkVqjFEpbYisM8d2XOgXZTZKTLz9ngxGHPPfWT2GBpt1gIOucnXsXjE42eO5uu4BL9okQuQU3zltRE/oEjc/OCVi1y8fQErU/ctLE9CEA/ciZD07WYan2joU2lv4/rpqsHhyecsre3Gj6xItcjiMFg2MmLJcKg8cZWlkpIVXdCXiyqpV4K67lD0khq1e3Fydf", + "bytecode": "H4sIAAAAAAAA/+1azW7TQBDexHYSO0lrwYs4ddKEWyUKFCj0V0Li5qbtc/jIkTfgAhIHxIUbEjwbXrqTfB6PQ0Q9rSJ1Jcvxznjmm9lvx7vbtsxNGxRXy/323b3t7ra/Y8qNdPfcPbldGzVoK9HC2NoAjO0NwOhtAEZ/AzAGChg1cHYaxNkCjFSTusXVK66wuKLi6puberYQYmB2glgC2gEOTLmwrWUQEvTb3UN3x4LZIMlHIfPbpP1ZMrkITbk1jD8NwaaC/SnZ93XsJ8Sht3nZvmF+PabH38H3jkDnqEbnGHSOa3ROQOekRucUdE5rdM5A56xG5xx0zkHHthD0jWmao+Mr5THeGbJYpdgCHd9pi/kzpswvw/xHRnU+jVrMH+Hh+Wmz/HR18CRkv6dkn+INhXgx/10Wb18HT0pcjAAP5+JAx/d4XS6S/4hh1eLiQBgbzA9xcUg6+RJPyGR+Xo2DZAHIaHwt795BfChDPFgfiKuxqXKFcCvPm1R53owe5s2iPcwbkGnPm6GR1xooa4MfWqtY2xeA7QPD1haw4Xjy753G97dYj0+U1xuL72lHyT7lrSfkE/dIFN+2qdbBHhsbyVZXGJtVNQnHi2JXrkmJct1Z5HpLiBdz2Ge5HoJsi+VOsjVckettQR/3rAOW61gnF6lUwygWqYZtMxnWMMKINUyZKyNlrqQPXFnm4q64onEmhN8IpT3g7uMa/PTbtm5uFs1j+cQcUc56qM9kIcj8vOwncs8++EFbhCNg+pl7prHrwDv0fiz47zD/JdxCH+aI2/KEPtK336D37redczQPnuZLe/bac/3Jrdp4Tvb3dexfkf1nKvYnu8SV5/kyl7i+t+0F+L7r9T36jxhWjfU9+kM8mB++vj/Iq1hjQYYc5DJP6CM/kq39Bm0Rt6TxbpBrWch8NzxXnpD9lzr2ZzTer/Jl7vhceQ2+72OukP+IYdWaK+QP8WB++Fw5zKtYY0GGHOQyT+jj/EbZQYO2iFsUD8bPuXAIfu/6bBv9RwyrFhekvGJ+OBfe5FWssSDDes9lntDHxw9lxE27NrBry0/wDl+P4dkFrdt96KPYtM8WqI7R/prWbNynz2LBswj8m2zA+j66u83HF3iHx+sJfTzXyDHS2xIwoB7yedXZGZ4v2OaDrMn5ZfPwFXDwmHENjviNKdcArb1K0XbWqQHoPzLVXGucja573sf/NojvxoKM8o9rej9vPpbpbPkPEcS9ALBg80GO+p/dM55DYxx7/4nzepqNrtPsOptkl5fjefaI2TeQw76C/2yazuY74/n0YpJm6e4//Ut7RJzPttE+E/ehqE/2Aqb/jXSL67v7zc8R0J/V+7VCr1Vz/2tD6PPzcp+0P8V9O+mT7yivYiRZH2R4JmLbwD1jvtAW4QiY/k/3TGOCe216Pxb895j/Em6hj+/b+4J+X9C34/OD7Lk7xq6xXukw+9jHsRF3LK//AP9hB7/hKQAA", + "debug_symbols": "XY5LCoQwDEDvknUXU2b8XkVEqkYplLbEVhjEu09aFGQ2TV5emuSAGce4DtouboO2O2AkbYxeB+MmFbSzXD1OATcOgRC5BA/Pv7witAFaG40RsCsTc9Pmlc0xKGL7EoB25sgDF20wZWfPoCZN/xt3RVqNBi9cop0eNnz9be6LPbkJ50iYJiUHr+vpZFkLWTe9gDdTXYmm4lxmVTRClp+EMncWjFV/psN+", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_0.snap index c4414386370..7c21aebb8c6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_0.snap @@ -43,14 +43,18 @@ expression: artifact "visibility": "public" }, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "H4sIAAAAAAAA/+1ZzW7TQBBex3YSO0lrwYs4ddKWWyUKFCj0V0Li5v49xx55Ay5wQFy4IcEL4qU7yefxuIqopyhSV7Ic78zOfDP77XrWCcxtG1dX4H9H/t7zd9ffN/VGunv+nt+vTTu0lWthDNYAY28NMIZrgDFaA4yxAkYNnP0OcQaAkfakQXUNqyuprrS6RuZ2P1sIMTC3QBwB3QTHpr6xrWQQEvTb3xN/xw2zQ5JPE+a3S/u7+fwiMfXWMf4iAZsK9nfIfqRjPycOvbd1+4b5DZkeH4PjjkDnqEXnGHSOW3ROQOekRecUdE5bdM5A56xF5xx0zkHHtQT0jemao7Nr5TnemrBYpdhiHd9FwPwZU+eXYf5To7qepgHzR3h4fnosPwMdPDnZHyrZp3gTIV7M/4DFO9LBUxAXU8DDuTjW8T1blYvkP2VYtbg4FuYG80NcnJCOXeJJmCyyzThIFoOM5tfx7gPEhzLEg/sDcTUzTa4QbuV1Uyivm+njulm0x3UDMu11MzFyrYGyHvihWsXZvgBsnxi2noAN55O/7zTev1U9PleuNxbv076SfcrbUMgnnpEovk3T3AeHbG4kWwNhbu7ak3C+KHblPSlX3ncWud4Q4sUcjliuJyDbYLmTbE3uyPWmoI9n1jHLdaaTi0LawygWaQ/bZDLcwwgj7mHKXJkqc6V45MoyFw/FFY1vQviOUDoDbj9twU+/XRtYs2ghyyfmiHI2RH0mS0AW2bqf1D9H4AdtEY6Y6Zf+meauD2NofCb47zP/NdxCH+aI2wqFPtJ376CP/rdbc7QOntulPXft+f78Xm12Sfb3dexfk/0XKvbn28SVl3aZS6zvXXsFvh+6vkf/KcOqUd+jP8SD+eH1/YFtYs0EGXKQy0Khj/xItvY7tEXckua7Q66VCfPd8Vp5RvZf69jfpfl+Y5e542vlLfj+H2uF/KcMq9ZaIX+IB/PD18qhbWLNBBlykMtCoY/zG2UHHdoiblE8GD/nwiH4fehv2+g/ZVi1uCDlFfPDufDONrFmggz3ey4LhT4+fygjbrrawNWWn2EMr8fw28WGqZ+vXcN8BsI4qR6m8cSRCGRdcsTF9hVwOPsRYMc6EvEbU+exVr1dta1VeIz+U9PMtcb3vVW/WfH/t3BsJsgo/1iXRrb7WHZ2l3/qE/diwIItAjnqf/HP+C0V49j7R5w3O+X0pihvynl5dTW7LJ8w+wZy6PIknTNwPblGZxU8y6A+2YuZ/jfSra7v/jc/i6I/p/frDr2g5f7XhtAX2XqfdMbBsx/pk+/UNjGSbAQyPFe7NvbPmC+0RThipv/TP9Oc4HmNxmeC/yHzX8Mt9PGz30jQHwn6bn5+kD1/x9g13nl9Zh/7ODbijuP1H+YZ//olKAAA", - "debug_symbols": "XY7dCoMwDIXfJde9WBmuzlcRkVqjFEpbYisM8d2XOgXZTZKTLz9ngxGHPPfWT2GBpt1gIOucnXsXjE42eO5uu4BL9okQuQU3zltRE/oEjc/OCVi1y8fQErU/ctLE9CEA/ciZD07WYan2joU2lv4/rpqsHhyecsre3Gj6xItcjiMFg2MmLJcKg8cZWlkpIVXdCXiyqpV4K67lD0khq1e3Fydf", + "bytecode": "H4sIAAAAAAAA/+1azW7TQBDexHYSO0lrwYs4ddKEWyUKFCj0V0Li5qbtc/jIkTfgAhIHxIUbEjwbXrqTfB6PQ0Q9rSJ1Jcvxznjmm9lvx7vbtsxNGxRXy/323b3t7ra/Y8qNdPfcPbldGzVoK9HC2NoAjO0NwOhtAEZ/AzAGChg1cHYaxNkCjFSTusXVK66wuKLi6puberYQYmB2glgC2gEOTLmwrWUQEvTb3UN3x4LZIMlHIfPbpP1ZMrkITbk1jD8NwaaC/SnZ93XsJ8Sht3nZvmF+PabH38H3jkDnqEbnGHSOa3ROQOekRucUdE5rdM5A56xG5xx0zkHHthD0jWmao+Mr5THeGbJYpdgCHd9pi/kzpswvw/xHRnU+jVrMH+Hh+Wmz/HR18CRkv6dkn+INhXgx/10Wb18HT0pcjAAP5+JAx/d4XS6S/4hh1eLiQBgbzA9xcUg6+RJPyGR+Xo2DZAHIaHwt795BfChDPFgfiKuxqXKFcCvPm1R53owe5s2iPcwbkGnPm6GR1xooa4MfWqtY2xeA7QPD1haw4Xjy753G97dYj0+U1xuL72lHyT7lrSfkE/dIFN+2qdbBHhsbyVZXGJtVNQnHi2JXrkmJct1Z5HpLiBdz2Ge5HoJsi+VOsjVckettQR/3rAOW61gnF6lUwygWqYZtMxnWMMKINUyZKyNlrqQPXFnm4q64onEmhN8IpT3g7uMa/PTbtm5uFs1j+cQcUc56qM9kIcj8vOwncs8++EFbhCNg+pl7prHrwDv0fiz47zD/JdxCH+aI2/KEPtK336D37redczQPnuZLe/bac/3Jrdp4Tvb3dexfkf1nKvYnu8SV5/kyl7i+t+0F+L7r9T36jxhWjfU9+kM8mB++vj/Iq1hjQYYc5DJP6CM/kq39Bm0Rt6TxbpBrWch8NzxXnpD9lzr2ZzTer/Jl7vhceQ2+72OukP+IYdWaK+QP8WB++Fw5zKtYY0GGHOQyT+jj/EbZQYO2iFsUD8bPuXAIfu/6bBv9RwyrFhekvGJ+OBfe5FWssSDDes9lntDHxw9lxE27NrBry0/wDl+P4dkFrdt96KPYtM8WqI7R/prWbNynz2LBswj8m2zA+j66u83HF3iHx+sJfTzXyDHS2xIwoB7yedXZGZ4v2OaDrMn5ZfPwFXDwmHENjviNKdcArb1K0XbWqQHoPzLVXGucja573sf/NojvxoKM8o9rej9vPpbpbPkPEcS9ALBg80GO+p/dM55DYxx7/4nzepqNrtPsOptkl5fjefaI2TeQw76C/2yazuY74/n0YpJm6e4//Ut7RJzPttE+E/ehqE/2Aqb/jXSL67v7zc8R0J/V+7VCr1Vz/2tD6PPzcp+0P8V9O+mT7yivYiRZH2R4JmLbwD1jvtAW4QiY/k/3TGOCe216Pxb895j/Em6hj+/b+4J+X9C34/OD7Lk7xq6xXukw+9jHsRF3LK//AP9hB7/hKQAA", + "debug_symbols": "XY5LCoQwDEDvknUXU2b8XkVEqkYplLbEVhjEu09aFGQ2TV5emuSAGce4DtouboO2O2AkbYxeB+MmFbSzXD1OATcOgRC5BA/Pv7witAFaG40RsCsTc9Pmlc0xKGL7EoB25sgDF20wZWfPoCZN/xt3RVqNBi9cop0eNnz9be6LPbkJ50iYJiUHr+vpZFkLWTe9gDdTXYmm4lxmVTRClp+EMncWjFV/psN+", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index c4414386370..7c21aebb8c6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -43,14 +43,18 @@ expression: artifact "visibility": "public" }, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "H4sIAAAAAAAA/+1ZzW7TQBBex3YSO0lrwYs4ddKWWyUKFCj0V0Li5v49xx55Ay5wQFy4IcEL4qU7yefxuIqopyhSV7Ic78zOfDP77XrWCcxtG1dX4H9H/t7zd9ffN/VGunv+nt+vTTu0lWthDNYAY28NMIZrgDFaA4yxAkYNnP0OcQaAkfakQXUNqyuprrS6RuZ2P1sIMTC3QBwB3QTHpr6xrWQQEvTb3xN/xw2zQ5JPE+a3S/u7+fwiMfXWMf4iAZsK9nfIfqRjPycOvbd1+4b5DZkeH4PjjkDnqEXnGHSOW3ROQOekRecUdE5bdM5A56xF5xx0zkHHtQT0jemao7Nr5TnemrBYpdhiHd9FwPwZU+eXYf5To7qepgHzR3h4fnosPwMdPDnZHyrZp3gTIV7M/4DFO9LBUxAXU8DDuTjW8T1blYvkP2VYtbg4FuYG80NcnJCOXeJJmCyyzThIFoOM5tfx7gPEhzLEg/sDcTUzTa4QbuV1Uyivm+njulm0x3UDMu11MzFyrYGyHvihWsXZvgBsnxi2noAN55O/7zTev1U9PleuNxbv076SfcrbUMgnnpEovk3T3AeHbG4kWwNhbu7ak3C+KHblPSlX3ncWud4Q4sUcjliuJyDbYLmTbE3uyPWmoI9n1jHLdaaTi0LawygWaQ/bZDLcwwgj7mHKXJkqc6V45MoyFw/FFY1vQviOUDoDbj9twU+/XRtYs2ghyyfmiHI2RH0mS0AW2bqf1D9H4AdtEY6Y6Zf+meauD2NofCb47zP/NdxCH+aI2wqFPtJ376CP/rdbc7QOntulPXft+f78Xm12Sfb3dexfk/0XKvbn28SVl3aZS6zvXXsFvh+6vkf/KcOqUd+jP8SD+eH1/YFtYs0EGXKQy0Khj/xItvY7tEXckua7Q66VCfPd8Vp5RvZf69jfpfl+Y5e542vlLfj+H2uF/KcMq9ZaIX+IB/PD18qhbWLNBBlykMtCoY/zG2UHHdoiblE8GD/nwiH4fehv2+g/ZVi1uCDlFfPDufDONrFmggz3ey4LhT4+fygjbrrawNWWn2EMr8fw28WGqZ+vXcN8BsI4qR6m8cSRCGRdcsTF9hVwOPsRYMc6EvEbU+exVr1dta1VeIz+U9PMtcb3vVW/WfH/t3BsJsgo/1iXRrb7WHZ2l3/qE/diwIItAjnqf/HP+C0V49j7R5w3O+X0pihvynl5dTW7LJ8w+wZy6PIknTNwPblGZxU8y6A+2YuZ/jfSra7v/jc/i6I/p/frDr2g5f7XhtAX2XqfdMbBsx/pk+/UNjGSbAQyPFe7NvbPmC+0RThipv/TP9Oc4HmNxmeC/yHzX8Mt9PGz30jQHwn6bn5+kD1/x9g13nl9Zh/7ODbijuP1H+YZ//olKAAA", - "debug_symbols": "XY7dCoMwDIXfJde9WBmuzlcRkVqjFEpbYisM8d2XOgXZTZKTLz9ngxGHPPfWT2GBpt1gIOucnXsXjE42eO5uu4BL9okQuQU3zltRE/oEjc/OCVi1y8fQErU/ctLE9CEA/ciZD07WYan2joU2lv4/rpqsHhyecsre3Gj6xItcjiMFg2MmLJcKg8cZWlkpIVXdCXiyqpV4K67lD0khq1e3Fydf", + "bytecode": "H4sIAAAAAAAA/+1azW7TQBDexHYSO0lrwYs4ddKEWyUKFCj0V0Li5qbtc/jIkTfgAhIHxIUbEjwbXrqTfB6PQ0Q9rSJ1Jcvxznjmm9lvx7vbtsxNGxRXy/323b3t7ra/Y8qNdPfcPbldGzVoK9HC2NoAjO0NwOhtAEZ/AzAGChg1cHYaxNkCjFSTusXVK66wuKLi6puberYQYmB2glgC2gEOTLmwrWUQEvTb3UN3x4LZIMlHIfPbpP1ZMrkITbk1jD8NwaaC/SnZ93XsJ8Sht3nZvmF+PabH38H3jkDnqEbnGHSOa3ROQOekRucUdE5rdM5A56xG5xx0zkHHthD0jWmao+Mr5THeGbJYpdgCHd9pi/kzpswvw/xHRnU+jVrMH+Hh+Wmz/HR18CRkv6dkn+INhXgx/10Wb18HT0pcjAAP5+JAx/d4XS6S/4hh1eLiQBgbzA9xcUg6+RJPyGR+Xo2DZAHIaHwt795BfChDPFgfiKuxqXKFcCvPm1R53owe5s2iPcwbkGnPm6GR1xooa4MfWqtY2xeA7QPD1haw4Xjy753G97dYj0+U1xuL72lHyT7lrSfkE/dIFN+2qdbBHhsbyVZXGJtVNQnHi2JXrkmJct1Z5HpLiBdz2Ge5HoJsi+VOsjVckettQR/3rAOW61gnF6lUwygWqYZtMxnWMMKINUyZKyNlrqQPXFnm4q64onEmhN8IpT3g7uMa/PTbtm5uFs1j+cQcUc56qM9kIcj8vOwncs8++EFbhCNg+pl7prHrwDv0fiz47zD/JdxCH+aI2/KEPtK336D37redczQPnuZLe/bac/3Jrdp4Tvb3dexfkf1nKvYnu8SV5/kyl7i+t+0F+L7r9T36jxhWjfU9+kM8mB++vj/Iq1hjQYYc5DJP6CM/kq39Bm0Rt6TxbpBrWch8NzxXnpD9lzr2ZzTer/Jl7vhceQ2+72OukP+IYdWaK+QP8WB++Fw5zKtYY0GGHOQyT+jj/EbZQYO2iFsUD8bPuXAIfu/6bBv9RwyrFhekvGJ+OBfe5FWssSDDes9lntDHxw9lxE27NrBry0/wDl+P4dkFrdt96KPYtM8WqI7R/prWbNynz2LBswj8m2zA+j66u83HF3iHx+sJfTzXyDHS2xIwoB7yedXZGZ4v2OaDrMn5ZfPwFXDwmHENjviNKdcArb1K0XbWqQHoPzLVXGucja573sf/NojvxoKM8o9rej9vPpbpbPkPEcS9ALBg80GO+p/dM55DYxx7/4nzepqNrtPsOptkl5fjefaI2TeQw76C/2yazuY74/n0YpJm6e4//Ut7RJzPttE+E/ehqE/2Aqb/jXSL67v7zc8R0J/V+7VCr1Vz/2tD6PPzcp+0P8V9O+mT7yivYiRZH2R4JmLbwD1jvtAW4QiY/k/3TGOCe216Pxb895j/Em6hj+/b+4J+X9C34/OD7Lk7xq6xXukw+9jHsRF3LK//AP9hB7/hKQAA", + "debug_symbols": "XY5LCoQwDEDvknUXU2b8XkVEqkYplLbEVhjEu09aFGQ2TV5emuSAGce4DtouboO2O2AkbYxeB+MmFbSzXD1OATcOgRC5BA/Pv7witAFaG40RsCsTc9Pmlc0xKGL7EoB25sgDF20wZWfPoCZN/xt3RVqNBi9cop0eNnz9be6LPbkJ50iYJiUHr+vpZFkLWTe9gDdTXYmm4lxmVTRClp+EMncWjFV/psN+", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index c4414386370..7c21aebb8c6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -43,14 +43,18 @@ expression: artifact "visibility": "public" }, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "H4sIAAAAAAAA/+1ZzW7TQBBex3YSO0lrwYs4ddKWWyUKFCj0V0Li5v49xx55Ay5wQFy4IcEL4qU7yefxuIqopyhSV7Ic78zOfDP77XrWCcxtG1dX4H9H/t7zd9ffN/VGunv+nt+vTTu0lWthDNYAY28NMIZrgDFaA4yxAkYNnP0OcQaAkfakQXUNqyuprrS6RuZ2P1sIMTC3QBwB3QTHpr6xrWQQEvTb3xN/xw2zQ5JPE+a3S/u7+fwiMfXWMf4iAZsK9nfIfqRjPycOvbd1+4b5DZkeH4PjjkDnqEXnGHSOW3ROQOekRecUdE5bdM5A56xF5xx0zkHHtQT0jemao7Nr5TnemrBYpdhiHd9FwPwZU+eXYf5To7qepgHzR3h4fnosPwMdPDnZHyrZp3gTIV7M/4DFO9LBUxAXU8DDuTjW8T1blYvkP2VYtbg4FuYG80NcnJCOXeJJmCyyzThIFoOM5tfx7gPEhzLEg/sDcTUzTa4QbuV1Uyivm+njulm0x3UDMu11MzFyrYGyHvihWsXZvgBsnxi2noAN55O/7zTev1U9PleuNxbv076SfcrbUMgnnpEovk3T3AeHbG4kWwNhbu7ak3C+KHblPSlX3ncWud4Q4sUcjliuJyDbYLmTbE3uyPWmoI9n1jHLdaaTi0LawygWaQ/bZDLcwwgj7mHKXJkqc6V45MoyFw/FFY1vQviOUDoDbj9twU+/XRtYs2ghyyfmiHI2RH0mS0AW2bqf1D9H4AdtEY6Y6Zf+meauD2NofCb47zP/NdxCH+aI2wqFPtJ376CP/rdbc7QOntulPXft+f78Xm12Sfb3dexfk/0XKvbn28SVl3aZS6zvXXsFvh+6vkf/KcOqUd+jP8SD+eH1/YFtYs0EGXKQy0Khj/xItvY7tEXckua7Q66VCfPd8Vp5RvZf69jfpfl+Y5e542vlLfj+H2uF/KcMq9ZaIX+IB/PD18qhbWLNBBlykMtCoY/zG2UHHdoiblE8GD/nwiH4fehv2+g/ZVi1uCDlFfPDufDONrFmggz3ey4LhT4+fygjbrrawNWWn2EMr8fw28WGqZ+vXcN8BsI4qR6m8cSRCGRdcsTF9hVwOPsRYMc6EvEbU+exVr1dta1VeIz+U9PMtcb3vVW/WfH/t3BsJsgo/1iXRrb7WHZ2l3/qE/diwIItAjnqf/HP+C0V49j7R5w3O+X0pihvynl5dTW7LJ8w+wZy6PIknTNwPblGZxU8y6A+2YuZ/jfSra7v/jc/i6I/p/frDr2g5f7XhtAX2XqfdMbBsx/pk+/UNjGSbAQyPFe7NvbPmC+0RThipv/TP9Oc4HmNxmeC/yHzX8Mt9PGz30jQHwn6bn5+kD1/x9g13nl9Zh/7ODbijuP1H+YZ//olKAAA", - "debug_symbols": "XY7dCoMwDIXfJde9WBmuzlcRkVqjFEpbYisM8d2XOgXZTZKTLz9ngxGHPPfWT2GBpt1gIOucnXsXjE42eO5uu4BL9okQuQU3zltRE/oEjc/OCVi1y8fQErU/ctLE9CEA/ciZD07WYan2joU2lv4/rpqsHhyecsre3Gj6xItcjiMFg2MmLJcKg8cZWlkpIVXdCXiyqpV4K67lD0khq1e3Fydf", + "bytecode": "H4sIAAAAAAAA/+1azW7TQBDexHYSO0lrwYs4ddKEWyUKFCj0V0Li5qbtc/jIkTfgAhIHxIUbEjwbXrqTfB6PQ0Q9rSJ1Jcvxznjmm9lvx7vbtsxNGxRXy/323b3t7ra/Y8qNdPfcPbldGzVoK9HC2NoAjO0NwOhtAEZ/AzAGChg1cHYaxNkCjFSTusXVK66wuKLi6puberYQYmB2glgC2gEOTLmwrWUQEvTb3UN3x4LZIMlHIfPbpP1ZMrkITbk1jD8NwaaC/SnZ93XsJ8Sht3nZvmF+PabH38H3jkDnqEbnGHSOa3ROQOekRucUdE5rdM5A56xG5xx0zkHHthD0jWmao+Mr5THeGbJYpdgCHd9pi/kzpswvw/xHRnU+jVrMH+Hh+Wmz/HR18CRkv6dkn+INhXgx/10Wb18HT0pcjAAP5+JAx/d4XS6S/4hh1eLiQBgbzA9xcUg6+RJPyGR+Xo2DZAHIaHwt795BfChDPFgfiKuxqXKFcCvPm1R53owe5s2iPcwbkGnPm6GR1xooa4MfWqtY2xeA7QPD1haw4Xjy753G97dYj0+U1xuL72lHyT7lrSfkE/dIFN+2qdbBHhsbyVZXGJtVNQnHi2JXrkmJct1Z5HpLiBdz2Ge5HoJsi+VOsjVckettQR/3rAOW61gnF6lUwygWqYZtMxnWMMKINUyZKyNlrqQPXFnm4q64onEmhN8IpT3g7uMa/PTbtm5uFs1j+cQcUc56qM9kIcj8vOwncs8++EFbhCNg+pl7prHrwDv0fiz47zD/JdxCH+aI2/KEPtK336D37redczQPnuZLe/bac/3Jrdp4Tvb3dexfkf1nKvYnu8SV5/kyl7i+t+0F+L7r9T36jxhWjfU9+kM8mB++vj/Iq1hjQYYc5DJP6CM/kq39Bm0Rt6TxbpBrWch8NzxXnpD9lzr2ZzTer/Jl7vhceQ2+72OukP+IYdWaK+QP8WB++Fw5zKtYY0GGHOQyT+jj/EbZQYO2iFsUD8bPuXAIfu/6bBv9RwyrFhekvGJ+OBfe5FWssSDDes9lntDHxw9lxE27NrBry0/wDl+P4dkFrdt96KPYtM8WqI7R/prWbNynz2LBswj8m2zA+j66u83HF3iHx+sJfTzXyDHS2xIwoB7yedXZGZ4v2OaDrMn5ZfPwFXDwmHENjviNKdcArb1K0XbWqQHoPzLVXGucja573sf/NojvxoKM8o9rej9vPpbpbPkPEcS9ALBg80GO+p/dM55DYxx7/4nzepqNrtPsOptkl5fjefaI2TeQw76C/2yazuY74/n0YpJm6e4//Ut7RJzPttE+E/ehqE/2Aqb/jXSL67v7zc8R0J/V+7VCr1Vz/2tD6PPzcp+0P8V9O+mT7yivYiRZH2R4JmLbwD1jvtAW4QiY/k/3TGOCe216Pxb895j/Em6hj+/b+4J+X9C34/OD7Lk7xq6xXukw+9jHsRF3LK//AP9hB7/hKQAA", + "debug_symbols": "XY5LCoQwDEDvknUXU2b8XkVEqkYplLbEVhjEu09aFGQ2TV5emuSAGce4DtouboO2O2AkbYxeB+MmFbSzXD1OATcOgRC5BA/Pv7witAFaG40RsCsTc9Pmlc0xKGL7EoB25sgDF20wZWfPoCZN/xt3RVqNBi9cop0eNnz9be6LPbkJ50iYJiUHr+vpZFkLWTe9gDdTXYmm4lxmVTRClp+EMncWjFV/psN+", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_0.snap index c4414386370..7c21aebb8c6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_0.snap @@ -43,14 +43,18 @@ expression: artifact "visibility": "public" }, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "H4sIAAAAAAAA/+1ZzW7TQBBex3YSO0lrwYs4ddKWWyUKFCj0V0Li5v49xx55Ay5wQFy4IcEL4qU7yefxuIqopyhSV7Ic78zOfDP77XrWCcxtG1dX4H9H/t7zd9ffN/VGunv+nt+vTTu0lWthDNYAY28NMIZrgDFaA4yxAkYNnP0OcQaAkfakQXUNqyuprrS6RuZ2P1sIMTC3QBwB3QTHpr6xrWQQEvTb3xN/xw2zQ5JPE+a3S/u7+fwiMfXWMf4iAZsK9nfIfqRjPycOvbd1+4b5DZkeH4PjjkDnqEXnGHSOW3ROQOekRecUdE5bdM5A56xF5xx0zkHHtQT0jemao7Nr5TnemrBYpdhiHd9FwPwZU+eXYf5To7qepgHzR3h4fnosPwMdPDnZHyrZp3gTIV7M/4DFO9LBUxAXU8DDuTjW8T1blYvkP2VYtbg4FuYG80NcnJCOXeJJmCyyzThIFoOM5tfx7gPEhzLEg/sDcTUzTa4QbuV1Uyivm+njulm0x3UDMu11MzFyrYGyHvihWsXZvgBsnxi2noAN55O/7zTev1U9PleuNxbv076SfcrbUMgnnpEovk3T3AeHbG4kWwNhbu7ak3C+KHblPSlX3ncWud4Q4sUcjliuJyDbYLmTbE3uyPWmoI9n1jHLdaaTi0LawygWaQ/bZDLcwwgj7mHKXJkqc6V45MoyFw/FFY1vQviOUDoDbj9twU+/XRtYs2ghyyfmiHI2RH0mS0AW2bqf1D9H4AdtEY6Y6Zf+meauD2NofCb47zP/NdxCH+aI2wqFPtJ376CP/rdbc7QOntulPXft+f78Xm12Sfb3dexfk/0XKvbn28SVl3aZS6zvXXsFvh+6vkf/KcOqUd+jP8SD+eH1/YFtYs0EGXKQy0Khj/xItvY7tEXckua7Q66VCfPd8Vp5RvZf69jfpfl+Y5e542vlLfj+H2uF/KcMq9ZaIX+IB/PD18qhbWLNBBlykMtCoY/zG2UHHdoiblE8GD/nwiH4fehv2+g/ZVi1uCDlFfPDufDONrFmggz3ey4LhT4+fygjbrrawNWWn2EMr8fw28WGqZ+vXcN8BsI4qR6m8cSRCGRdcsTF9hVwOPsRYMc6EvEbU+exVr1dta1VeIz+U9PMtcb3vVW/WfH/t3BsJsgo/1iXRrb7WHZ2l3/qE/diwIItAjnqf/HP+C0V49j7R5w3O+X0pihvynl5dTW7LJ8w+wZy6PIknTNwPblGZxU8y6A+2YuZ/jfSra7v/jc/i6I/p/frDr2g5f7XhtAX2XqfdMbBsx/pk+/UNjGSbAQyPFe7NvbPmC+0RThipv/TP9Oc4HmNxmeC/yHzX8Mt9PGz30jQHwn6bn5+kD1/x9g13nl9Zh/7ODbijuP1H+YZ//olKAAA", - "debug_symbols": "XY7dCoMwDIXfJde9WBmuzlcRkVqjFEpbYisM8d2XOgXZTZKTLz9ngxGHPPfWT2GBpt1gIOucnXsXjE42eO5uu4BL9okQuQU3zltRE/oEjc/OCVi1y8fQErU/ctLE9CEA/ciZD07WYan2joU2lv4/rpqsHhyecsre3Gj6xItcjiMFg2MmLJcKg8cZWlkpIVXdCXiyqpV4K67lD0khq1e3Fydf", + "bytecode": "H4sIAAAAAAAA/+1azW7TQBDexHYSO0lrwYs4ddKEWyUKFCj0V0Li5qbtc/jIkTfgAhIHxIUbEjwbXrqTfB6PQ0Q9rSJ1Jcvxznjmm9lvx7vbtsxNGxRXy/323b3t7ra/Y8qNdPfcPbldGzVoK9HC2NoAjO0NwOhtAEZ/AzAGChg1cHYaxNkCjFSTusXVK66wuKLi6puberYQYmB2glgC2gEOTLmwrWUQEvTb3UN3x4LZIMlHIfPbpP1ZMrkITbk1jD8NwaaC/SnZ93XsJ8Sht3nZvmF+PabH38H3jkDnqEbnGHSOa3ROQOekRucUdE5rdM5A56xG5xx0zkHHthD0jWmao+Mr5THeGbJYpdgCHd9pi/kzpswvw/xHRnU+jVrMH+Hh+Wmz/HR18CRkv6dkn+INhXgx/10Wb18HT0pcjAAP5+JAx/d4XS6S/4hh1eLiQBgbzA9xcUg6+RJPyGR+Xo2DZAHIaHwt795BfChDPFgfiKuxqXKFcCvPm1R53owe5s2iPcwbkGnPm6GR1xooa4MfWqtY2xeA7QPD1haw4Xjy753G97dYj0+U1xuL72lHyT7lrSfkE/dIFN+2qdbBHhsbyVZXGJtVNQnHi2JXrkmJct1Z5HpLiBdz2Ge5HoJsi+VOsjVckettQR/3rAOW61gnF6lUwygWqYZtMxnWMMKINUyZKyNlrqQPXFnm4q64onEmhN8IpT3g7uMa/PTbtm5uFs1j+cQcUc56qM9kIcj8vOwncs8++EFbhCNg+pl7prHrwDv0fiz47zD/JdxCH+aI2/KEPtK336D37redczQPnuZLe/bac/3Jrdp4Tvb3dexfkf1nKvYnu8SV5/kyl7i+t+0F+L7r9T36jxhWjfU9+kM8mB++vj/Iq1hjQYYc5DJP6CM/kq39Bm0Rt6TxbpBrWch8NzxXnpD9lzr2ZzTer/Jl7vhceQ2+72OukP+IYdWaK+QP8WB++Fw5zKtYY0GGHOQyT+jj/EbZQYO2iFsUD8bPuXAIfu/6bBv9RwyrFhekvGJ+OBfe5FWssSDDes9lntDHxw9lxE27NrBry0/wDl+P4dkFrdt96KPYtM8WqI7R/prWbNynz2LBswj8m2zA+j66u83HF3iHx+sJfTzXyDHS2xIwoB7yedXZGZ4v2OaDrMn5ZfPwFXDwmHENjviNKdcArb1K0XbWqQHoPzLVXGucja573sf/NojvxoKM8o9rej9vPpbpbPkPEcS9ALBg80GO+p/dM55DYxx7/4nzepqNrtPsOptkl5fjefaI2TeQw76C/2yazuY74/n0YpJm6e4//Ut7RJzPttE+E/ehqE/2Aqb/jXSL67v7zc8R0J/V+7VCr1Vz/2tD6PPzcp+0P8V9O+mT7yivYiRZH2R4JmLbwD1jvtAW4QiY/k/3TGOCe216Pxb895j/Em6hj+/b+4J+X9C34/OD7Lk7xq6xXukw+9jHsRF3LK//AP9hB7/hKQAA", + "debug_symbols": "XY5LCoQwDEDvknUXU2b8XkVEqkYplLbEVhjEu09aFGQ2TV5emuSAGce4DtouboO2O2AkbYxeB+MmFbSzXD1OATcOgRC5BA/Pv7witAFaG40RsCsTc9Pmlc0xKGL7EoB25sgDF20wZWfPoCZN/xt3RVqNBi9cop0eNnz9be6LPbkJ50iYJiUHr+vpZFkLWTe9gDdTXYmm4lxmVTRClp+EMncWjFV/psN+", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index c4414386370..7c21aebb8c6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8174/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -43,14 +43,18 @@ expression: artifact "visibility": "public" }, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" } } }, - "bytecode": "H4sIAAAAAAAA/+1ZzW7TQBBex3YSO0lrwYs4ddKWWyUKFCj0V0Li5v49xx55Ay5wQFy4IcEL4qU7yefxuIqopyhSV7Ic78zOfDP77XrWCcxtG1dX4H9H/t7zd9ffN/VGunv+nt+vTTu0lWthDNYAY28NMIZrgDFaA4yxAkYNnP0OcQaAkfakQXUNqyuprrS6RuZ2P1sIMTC3QBwB3QTHpr6xrWQQEvTb3xN/xw2zQ5JPE+a3S/u7+fwiMfXWMf4iAZsK9nfIfqRjPycOvbd1+4b5DZkeH4PjjkDnqEXnGHSOW3ROQOekRecUdE5bdM5A56xF5xx0zkHHtQT0jemao7Nr5TnemrBYpdhiHd9FwPwZU+eXYf5To7qepgHzR3h4fnosPwMdPDnZHyrZp3gTIV7M/4DFO9LBUxAXU8DDuTjW8T1blYvkP2VYtbg4FuYG80NcnJCOXeJJmCyyzThIFoOM5tfx7gPEhzLEg/sDcTUzTa4QbuV1Uyivm+njulm0x3UDMu11MzFyrYGyHvihWsXZvgBsnxi2noAN55O/7zTev1U9PleuNxbv076SfcrbUMgnnpEovk3T3AeHbG4kWwNhbu7ak3C+KHblPSlX3ncWud4Q4sUcjliuJyDbYLmTbE3uyPWmoI9n1jHLdaaTi0LawygWaQ/bZDLcwwgj7mHKXJkqc6V45MoyFw/FFY1vQviOUDoDbj9twU+/XRtYs2ghyyfmiHI2RH0mS0AW2bqf1D9H4AdtEY6Y6Zf+meauD2NofCb47zP/NdxCH+aI2wqFPtJ376CP/rdbc7QOntulPXft+f78Xm12Sfb3dexfk/0XKvbn28SVl3aZS6zvXXsFvh+6vkf/KcOqUd+jP8SD+eH1/YFtYs0EGXKQy0Khj/xItvY7tEXckua7Q66VCfPd8Vp5RvZf69jfpfl+Y5e542vlLfj+H2uF/KcMq9ZaIX+IB/PD18qhbWLNBBlykMtCoY/zG2UHHdoiblE8GD/nwiH4fehv2+g/ZVi1uCDlFfPDufDONrFmggz3ey4LhT4+fygjbrrawNWWn2EMr8fw28WGqZ+vXcN8BsI4qR6m8cSRCGRdcsTF9hVwOPsRYMc6EvEbU+exVr1dta1VeIz+U9PMtcb3vVW/WfH/t3BsJsgo/1iXRrb7WHZ2l3/qE/diwIItAjnqf/HP+C0V49j7R5w3O+X0pihvynl5dTW7LJ8w+wZy6PIknTNwPblGZxU8y6A+2YuZ/jfSra7v/jc/i6I/p/frDr2g5f7XhtAX2XqfdMbBsx/pk+/UNjGSbAQyPFe7NvbPmC+0RThipv/TP9Oc4HmNxmeC/yHzX8Mt9PGz30jQHwn6bn5+kD1/x9g13nl9Zh/7ODbijuP1H+YZ//olKAAA", - "debug_symbols": "XY7dCoMwDIXfJde9WBmuzlcRkVqjFEpbYisM8d2XOgXZTZKTLz9ngxGHPPfWT2GBpt1gIOucnXsXjE42eO5uu4BL9okQuQU3zltRE/oEjc/OCVi1y8fQErU/ctLE9CEA/ciZD07WYan2joU2lv4/rpqsHhyecsre3Gj6xItcjiMFg2MmLJcKg8cZWlkpIVXdCXiyqpV4K67lD0khq1e3Fydf", + "bytecode": "H4sIAAAAAAAA/+1azW7TQBDexHYSO0lrwYs4ddKEWyUKFCj0V0Li5qbtc/jIkTfgAhIHxIUbEjwbXrqTfB6PQ0Q9rSJ1Jcvxznjmm9lvx7vbtsxNGxRXy/323b3t7ra/Y8qNdPfcPbldGzVoK9HC2NoAjO0NwOhtAEZ/AzAGChg1cHYaxNkCjFSTusXVK66wuKLi6puberYQYmB2glgC2gEOTLmwrWUQEvTb3UN3x4LZIMlHIfPbpP1ZMrkITbk1jD8NwaaC/SnZ93XsJ8Sht3nZvmF+PabH38H3jkDnqEbnGHSOa3ROQOekRucUdE5rdM5A56xG5xx0zkHHthD0jWmao+Mr5THeGbJYpdgCHd9pi/kzpswvw/xHRnU+jVrMH+Hh+Wmz/HR18CRkv6dkn+INhXgx/10Wb18HT0pcjAAP5+JAx/d4XS6S/4hh1eLiQBgbzA9xcUg6+RJPyGR+Xo2DZAHIaHwt795BfChDPFgfiKuxqXKFcCvPm1R53owe5s2iPcwbkGnPm6GR1xooa4MfWqtY2xeA7QPD1haw4Xjy753G97dYj0+U1xuL72lHyT7lrSfkE/dIFN+2qdbBHhsbyVZXGJtVNQnHi2JXrkmJct1Z5HpLiBdz2Ge5HoJsi+VOsjVckettQR/3rAOW61gnF6lUwygWqYZtMxnWMMKINUyZKyNlrqQPXFnm4q64onEmhN8IpT3g7uMa/PTbtm5uFs1j+cQcUc56qM9kIcj8vOwncs8++EFbhCNg+pl7prHrwDv0fiz47zD/JdxCH+aI2/KEPtK336D37redczQPnuZLe/bac/3Jrdp4Tvb3dexfkf1nKvYnu8SV5/kyl7i+t+0F+L7r9T36jxhWjfU9+kM8mB++vj/Iq1hjQYYc5DJP6CM/kq39Bm0Rt6TxbpBrWch8NzxXnpD9lzr2ZzTer/Jl7vhceQ2+72OukP+IYdWaK+QP8WB++Fw5zKtYY0GGHOQyT+jj/EbZQYO2iFsUD8bPuXAIfu/6bBv9RwyrFhekvGJ+OBfe5FWssSDDes9lntDHxw9lxE27NrBry0/wDl+P4dkFrdt96KPYtM8WqI7R/prWbNynz2LBswj8m2zA+j66u83HF3iHx+sJfTzXyDHS2xIwoB7yedXZGZ4v2OaDrMn5ZfPwFXDwmHENjviNKdcArb1K0XbWqQHoPzLVXGucja573sf/NojvxoKM8o9rej9vPpbpbPkPEcS9ALBg80GO+p/dM55DYxx7/4nzepqNrtPsOptkl5fjefaI2TeQw76C/2yazuY74/n0YpJm6e4//Ut7RJzPttE+E/ehqE/2Aqb/jXSL67v7zc8R0J/V+7VCr1Vz/2tD6PPzcp+0P8V9O+mT7yivYiRZH2R4JmLbwD1jvtAW4QiY/k/3TGOCe216Pxb895j/Em6hj+/b+4J+X9C34/OD7Lk7xq6xXukw+9jHsRF3LK//AP9hB7/hKQAA", + "debug_symbols": "XY5LCoQwDEDvknUXU2b8XkVEqkYplLbEVhjEu09aFGQ2TV5emuSAGce4DtouboO2O2AkbYxeB+MmFbSzXD1OATcOgRC5BA/Pv7witAFaG40RsCsTc9Pmlc0xKGL7EoB25sgDF20wZWfPoCZN/xt3RVqNBi9cop0eNnz9be6LPbkJ50iYJiUHr+vpZFkLWTe9gDdTXYmm4lxmVTRClp+EMncWjFV/psN+", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 31802918a86..77b7fb93038 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -50,8 +50,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_0.snap index d0d51025215..0a2a2413310 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_0.snap @@ -50,8 +50,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "H4sIAAAAAAAA/+1dzW4jxxHu4ZCSSIoitZKl3TiKvW9AcvinS6IglHalrG1pJWXjn7XNH9HxxQ6CHH1gAgRITkGAAIFfwKcAueQF8gR5oFyybU1RxWLNiFx+vRrKLECY4XTxq69rqqt6ejgaz1xL6dWfF+6nxdYez5txId2DcFueTypArLIrjt4CcEwtAEd/ATimF4BjZgE4riwAx9UF4Li2AByzC8Ax54CjC555IE/LLW3GBc13fQHOfWEBOG4sAMeiWYwxVHLE06yEWztIbeDbwLInzjqmZMYny7ZTdlJmJz12EGbC79uiY5O6TZo5MynkjP/619ts+DnF2oETqUpW2EXit8qN/azSPyD/IBtiZpzgVyqEv+KGf3k1xPn18Aaf94Xs+kJPfsdjOh8ynQ8jdD5iOh9F6HzMdD6O0PmE6XwSofOS6byM0PmU6XwaofMZ0/ksQudzpvN5hE6H6XQidLpMpxuh02c6/QidK6ZzFaEzYDqDCJ0vmM4XQifL9o1Bj+F6y/EY6BbMeNwb1heyverGds8T9oy58TlvI/s54zLfXC82cHvER/qH6kGBdIY3fDzRlh5O9oPaMqyNzq+tTzWmJ2MrI9qIi5VeiJc14/ELris1xzFZu8OYrN/HmPRFW3o42Y9ZY5L7RMYkv/D5zfAG42cM7+tw323+vJ4D8XECPj/lLYU/t2VldXjjD/Kbz46Rz+kcrHF90ZZlbenhuJ1c+DnN7HAs4pER+j8NPxfD7Qr7Dn2/pNhfEfbHeCvHpF+yin5W0bdx2Az37Tyf5rW/GN7g4RaKGy3Cb7vBrxP+oRv8HuEfucEfEP4TJ/jVMuE/dYLfbBL+sRv8KuGfuPF/jXLBL0N8smGFbD9jtt/0nI3bzwmuLuojt8f5cP/I+vjecJJrSWnjOUa2+coxsqNhtYFYhwnFOgJiPQFiPQViIft4DMRCnkfKXVo+sXIQbstzSlbYRs/PCP99N/xHa3gfuOE/wj9l+MBaO6pVZ07wgw7hP3eC32gQ/rkb/NEa6oUb/C7hX7rBvyL8XznBb474v3CD37fzfXu9+E2YwOgak65NyaaVpK5XOVoniV0b4P7hcx8v9KfkWhJtVuT11ZpiZ02xo2G1gViHCcU6AmI9AWI9BWIh+3gMxEKeR5r7FM1kPpG5ho8l5LyFbFF+TSv94NxSQp/vW8mIY38Ltxbrj/54/7R8shrjOy33ab5bEb7LOvZdTvFdNsZ3OdaWU3xHx741ON+tKHyyCh8X93zkD0ytUNu6Ge8XbyuwNs5fii8+8z5Z3/2J1XSpJ/nwOCJuGdH2Xbh1fd/4geDJbRUV229ofhIb99o4nDXu/xlutbjn8424OYiWM6J8Z4XWcByPiZHv8orvcjG+y7O2vOI7OvZvg/Ed94mWU/Nu/NOTeYGLlhdkzthg+py/FC1nUJ9mzRl8DI7ub4m2/4Rbx/5Tc0Ze2ObnHGS3k6S4sELrMDIuXqeW8Lj4boq4SJovniXIFwbmh6CaNZNzCKCf+5ovSbR8I2OuqPhtWj9Tn2b1c1J88SwBvljmomUu0nzhoP5V3OW58kSeA2KPfltbwGPXCXsDj92SeYWfa7JbYseBMd/whD1j9PVZsp8zkznQxfpsSfCR/pHrs5sK15LSJq8xNxU7m4odDSsPxFoHYhWAWDzeuf/omiCl2JXXC5kwkO7yeqGo8KV4cr324Qku/DqZ2yRus14n58MOa9fJKfY9Xzkmz31R4aP9HtCD+adR0eICh9/c1+aTOPxqT9YdsH+asvaA/VPTagwOPxjVzk03/MtUA2j8kw0eu1vsOG5sB7Vp6yfZzwmururnluAj/SPr57bCtSTarMh74tuKnW3FjoZ1CsS6AGKdA7EugVgnQCyk788SyEurV/PwOgbxQmIh+6jV36Scx/UE8rJyCMRqA7FQOUeb08yDtQHCsiJ/Z3PfcqFnJudj920MIWMCmb/s/iYIy0p7iMNKat1ezgvvJkdbWc4LZ8N6DsRCxkQbiIWcmyQ1vl44xJp2/Zn0tTVW7Xrb1mF6lvS3v/vyq98bIfI/IL0fQSwTQSAQ36ebVBzXE9/lkoloo8+BglMU3HjntcUfF4urtGjBF1e1mwIpoc/3qf/82J/DTmqLq1qQ8GMy4B4ofF434KZd4Jk54PhTS3EBRwTuIuAoqIpC9yD8XJ5TCmbypEjbjlbwpn5iguznzGRAuVhRfCD4RAU7+W5L4Voyk8Err+S0wN5S7GhYbSDWYQKxtJifh9cpiJeVp0CsIyDWMRALGRPyiQl+Xkf/OcI4zTWxxZPbLLL+zFI8/xVTPIuK74oxvispfNzWgWag3T3C4QcVefeFbPC+vcWO48595WraOkP2c4KrqzrzluAj/SPrzI7CtSTarMgVih3Fzo5iR8M6BWJdALHOgViXQKwTIBbS92cJ5KXls3mwNkBYVmQtvW+xavflHY+kxMR6AnlZOQRitYFYSYwJ9HiU1073La/afTn3SgKWFbliWFCwtOtj0p92njP3iiERy0cQ2BPfn2UBhz7nb2nfU7CKZnJwyQsfN5PfmwsfOqH8wofbJG4pMxlMPBgy4tj/wk5qFz5aoPBjcRc+hRjfbQvf7Tj23a6Z9N1OjO92WRvtc9/RMT+F813cTxlmHbC7ij5kwMoV16gBSwTuasBSYLm5Aqw0C2bS0STU9lDhTW2PWFtJcOfii8+8T7M+L8uDSnIjff6CKu35oYzQ3w4jyfGzH+rv5WUClnGEsV2ru/3NdH3g9jfN9bI2FnD4zZF/dp3gN0YrWw/d4PcJ/5Eb/NFzZD9yE58j/7zt5vw2CP/HbuKzS/h7bviP/sf+T9zwHz2j+465EVmH3mXHcXmx1fGEPWP0lVGynxNcwXl6tDL6ruAj/SNXRh8rXEuizYpcGX2s2Hms2NGwToFYF0CscyDWJRDrBIiF9P1ZAnnZfbkyOg/WBgjLilwZnYfXNoiX3d8FYiH9hYyJ9QTysoLKE56ZvBidB+shCMtKe4jD+iHkL8/gsFDn0e4/AmFZaQ9xWMj6iMRqA7FQvOy+vB6aBwtVh6wg6+PbQF7tIY5XCcjrCMTLShLnvnZ/OZ+YDes5EAsZE20g1iEQC5lXUdcdVpI4z7H7ci0qCVhWkGN7L6G8kDlnuZ5zNzXNynI9Z1nTZNshECup8fUChGX35T2FebBQedXuJ7Wm5RPKa1nTljXNpe+XNW1Z01yex2VNuzvfo+Le7iPvGRZAWMg+WkHm+6TmL2QfkfGFXMdsD3FYy7ncbFjLudzd+T6p92uR90WR93SQWIdArDYIyzO43zxYQY6hH8IcE4XF+yh/U27lINxWWs1yv97qdHrlQaMS9IJWo14NykG1369U6rV6o9/tXtWbtU7QuGqVB51aa9APev1BvxIE5cZ+IP9H+Rh2o99vVbuDXm0QtPZbjXJt0HgFcTWoBkGrdtWpd+u1ZqPbqPUblWqj2m/2atXeKxL7rf1yr94aEOe84gPt95e3PgCyIj7TE1tGcZDslBX5wAgR+0uEnvbiX028GA6ewKf2ouDAneL4RT6jJ5FoUs6fROI2iVtK6PN9Kxlx7Of+9VZ7EkkLBn5MDoh3FD7OA4sCgBvjn5McWG6fQAnKbt9qENS0N4bKvvFABA6MuifsmRBfnguynzOTgQnkU5EDlfhEDRrtjUr03ZLSJmNkQ7GzodjRsPaAWCkgFj27XDD6ONK2ZEcek3Z4GxUj7Y0phOU4fsvSXzyxc5sp1h/pL+7XjDj2Miax85zoK8ek73yFTzbCdwcY/4xyS4bxem94vbU5uSv6xN/a44vvcp7yzT1f+zeYV+G+Fhee+D61femP+8Nz4w/1ScaoOmJgdmuVKP+lp/DNV8I3/hv0DdmyuTfu7cu0r70Z3mfHZCxkFX3+BnaKPe2N59kpsPIxtnOKfjbGNueVi7CdZsc41zWhv6pwWlH6JvOuxOXf4/3g4/2D4fVW5gL+XZ4LRn0Z3uih4qzZus7Z33MN8SnXSEmzdq7/h1CZnwPapufgOWh2KoOgM+jUO/1+rdeR48EKna+8A/udZtDqVWu9ZrcevLp6vdW+jalvQl8UzHg+kbwkzjS1nmPJWq/9L9Y39XY0iv+ot6NlWH/keFllfZJvuP9rTK3n40kbY1HzJK6XNZO+A/qnW2CYJLzW/32KWu8rvGWt/5bV+n+IWi/HgpWo2iFrn1Y7tPictnZQX163dqRibN9WO6Ttu6wd3M/T1A4eP7J2+IpNHltaTuJ4MldwbrixUKlMk/O4/ZzSPxfXtelb/C2vazMK15KZzD/yTtms+Yq3nQKxLoBY50CsSyDWCRAL6fuzhPJ6DsRCxkQbiHUIxEpqfMk7UtPmtpn+7RWB88+yGPPEyCXu313F4XsCi9rtROb//NZuuGC0AAA=", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index ca23a7bef84..9bbc06f2b53 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/strings/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -50,8 +50,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n",