diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs index dfef0ed5bb1..fbd05470714 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs @@ -12,6 +12,7 @@ use super::{ instruction::{ Instruction, InstructionId, InstructionResultType, Intrinsic, TerminatorInstruction, }, + integer::IntegerConstant, map::DenseMap, types::{NumericType, Type}, value::{Value, ValueId, ValueMapping}, @@ -582,13 +583,22 @@ impl DataFlowGraph { } /// Returns the field element represented by this value if it is a numeric constant. - /// Returns None if the given value is not a numeric constant. + /// Returns `None` if the given value is not a numeric constant. + /// + /// Use `get_integer_constant` if the underlying values need to be compared as signed integers. pub(crate) fn get_numeric_constant(&self, value: ValueId) -> Option { self.get_numeric_constant_with_type(value).map(|(value, _typ)| value) } + /// Similar to `get_numeric_constant` but returns the value as a signed or unsigned integer. + /// Returns `None` if the given value is not an integer constant. + pub(crate) fn get_integer_constant(&self, value: ValueId) -> Option { + self.get_numeric_constant_with_type(value) + .and_then(|(f, t)| IntegerConstant::from_numeric_constant(f, t)) + } + /// Returns the field element and type represented by this value if it is a numeric constant. - /// Returns None if the given value is not a numeric constant. + /// Returns `None` if the given value is not a numeric constant. pub(crate) fn get_numeric_constant_with_type( &self, value: ValueId, diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs new file mode 100644 index 00000000000..38ff4dbbd39 --- /dev/null +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -0,0 +1,122 @@ +use std::cmp::Ordering; + +use acvm::{AcirField, FieldElement}; +use num_traits::Zero; + +use super::{instruction::binary, types::NumericType}; + +/// A `Signed` or `Unsigned` value of a `Value::NumericConstant`, converted to 128 bits. +/// +/// This type can be used in loops and other instances where values have to be compared, +/// with correct handling of negative values. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum IntegerConstant { + Signed { value: i128, bit_size: u32 }, + Unsigned { value: u128, bit_size: u32 }, +} + +impl IntegerConstant { + pub(crate) fn from_numeric_constant(field: FieldElement, typ: NumericType) -> Option { + match typ { + NumericType::Signed { bit_size } => { + binary::try_convert_field_element_to_signed_integer(field, bit_size) + .map(|value| Self::Signed { value, bit_size }) + } + NumericType::Unsigned { bit_size } => { + Some(Self::Unsigned { value: field.to_u128(), bit_size }) + } + NumericType::NativeField => None, + } + } + + /// Convert back into a field. + pub(crate) fn into_numeric_constant(self) -> (FieldElement, NumericType) { + match self { + Self::Signed { value, bit_size } => ( + binary::convert_signed_integer_to_field_element(value, bit_size), + NumericType::signed(bit_size), + ), + Self::Unsigned { value, bit_size } => { + (FieldElement::from(value), NumericType::unsigned(bit_size)) + } + } + } + + /// Reduce two constants into a result by applying functions on them if their signedness matches. + pub(crate) fn reduce( + self, + other: Self, + s: impl Fn(i128, i128) -> T, + u: impl Fn(u128, u128) -> T, + ) -> Option { + match (self, other) { + (Self::Signed { value: a, .. }, Self::Signed { value: b, .. }) => Some(s(a, b)), + (Self::Unsigned { value: a, .. }, Self::Unsigned { value: b, .. }) => Some(u(a, b)), + _ => None, + } + } + + /// Apply functions on signed/unsigned values. + pub(crate) fn apply(&self, s: impl Fn(i128) -> T, u: impl Fn(u128) -> T) -> T { + match self { + Self::Signed { value, .. } => s(*value), + Self::Unsigned { value, .. } => u(*value), + } + } + + /// Increment the value by 1, saturating at the maximum value. + pub(crate) fn inc(self) -> Self { + match self { + Self::Signed { value, bit_size } => { + Self::Signed { value: value.saturating_add(1), bit_size } + } + Self::Unsigned { value, bit_size } => { + Self::Unsigned { value: value.saturating_add(1), bit_size } + } + } + } + + /// Decrement the value by 1, saturating at the minimum value. + pub(crate) fn dec(self) -> Self { + match self { + Self::Signed { value, bit_size } => { + Self::Signed { value: value.saturating_sub(1), bit_size } + } + Self::Unsigned { value, bit_size } => { + Self::Unsigned { value: value.saturating_sub(1), bit_size } + } + } + } + + pub(crate) fn is_zero(&self) -> bool { + match self { + Self::Signed { value, .. } => value.is_zero(), + Self::Unsigned { value, .. } => value.is_zero(), + } + } +} + +impl PartialOrd for IntegerConstant { + fn partial_cmp(&self, other: &Self) -> Option { + match (self, other) { + (Self::Signed { value: a, .. }, Self::Signed { value: b, .. }) => a.partial_cmp(b), + (Self::Signed { value: a, .. }, Self::Unsigned { value: b, .. }) => { + if a.is_negative() || *b > i128::MAX as u128 { + Some(Ordering::Less) + } else { + let a: u128 = (*a).try_into().ok()?; + a.partial_cmp(b) + } + } + (Self::Unsigned { value: a, .. }, Self::Signed { value: b, .. }) => { + if b.is_negative() || *a > i128::MAX as u128 { + Some(Ordering::Less) + } else { + let b: u128 = (*b).try_into().ok()?; + a.partial_cmp(&b) + } + } + (Self::Unsigned { value: a, .. }, Self::Unsigned { value: b, .. }) => a.partial_cmp(b), + } + } +} diff --git a/compiler/noirc_evaluator/src/ssa/ir/mod.rs b/compiler/noirc_evaluator/src/ssa/ir/mod.rs index fefaaf4cb5d..3c750d12b7e 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/mod.rs @@ -6,6 +6,7 @@ pub(crate) mod dom; pub mod function; pub(crate) mod function_inserter; pub mod instruction; +pub(crate) mod integer; pub mod map; pub(crate) mod post_order; pub(crate) mod printer; diff --git a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs index 10619fe2aeb..c0e7f91f6c1 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs @@ -59,8 +59,9 @@ use crate::ssa::{ function_inserter::FunctionInserter, instruction::{ Binary, BinaryOp, ConstrainError, Instruction, InstructionId, - binary::{convert_signed_integer_to_field_element, eval_constant_binary_op}, + binary::eval_constant_binary_op, }, + integer::IntegerConstant, post_order::PostOrder, types::{NumericType, Type}, value::{Value, ValueId}, @@ -152,11 +153,11 @@ struct LoopInvariantContext<'f> { // This map is expected to only ever contain a singular value. // However, we store it in a map in order to match the definition of // `outer_induction_variables` as both maps share checks for evaluating binary operations. - current_induction_variables: HashMap, + current_induction_variables: HashMap, // Maps outer loop induction variable -> fixed lower and upper loop bound // This will be used by inner loops to determine whether they // have safe operations reliant upon an outer loop's maximum induction variable. - outer_induction_variables: HashMap, + outer_induction_variables: HashMap, // This context struct processes runs across all loops. // This stores the current loop's pre-header block. // It is wrapped in an Option as our SSA `Id` does not allow dummy values. @@ -368,9 +369,6 @@ impl<'f> LoopInvariantContext<'f> { fn set_induction_var_bounds(&mut self, loop_: &Loop, current_loop: bool) { let bounds = loop_.get_const_bounds(self.inserter.function, self.pre_header()); if let Some((lower_bound, upper_bound)) = bounds { - let bit_size = NumericType::length_type().bit_size(); - let lower_bound = convert_signed_integer_to_field_element(lower_bound, bit_size); - let upper_bound = convert_signed_integer_to_field_element(upper_bound, bit_size); let induction_variable = loop_.get_induction_variable(self.inserter.function); let induction_variable = self.inserter.resolve(induction_variable); if current_loop { @@ -399,7 +397,7 @@ impl<'f> LoopInvariantContext<'f> { let array_typ = self.inserter.function.dfg.type_of_value(*array); let upper_bound = self.outer_induction_variables.get(index).map(|bounds| bounds.1); if let (Type::Array(_, len), Some(upper_bound)) = (array_typ, upper_bound) { - upper_bound.to_u128() <= len.into() + upper_bound.apply(|i| i <= len.into(), |i| i <= len.into()) } else { false } @@ -411,7 +409,9 @@ impl<'f> LoopInvariantContext<'f> { // If the instruction were to be hoisted out of a loop that never executes it could potentially cause the program to fail when it is not meant to fail. let bounds = self.current_induction_variables.values().next().copied(); let does_loop_body_execute = bounds - .map(|(lower_bound, upper_bound)| !(upper_bound - lower_bound).is_zero()) + .and_then(|(lower_bound, upper_bound)| { + upper_bound.reduce(lower_bound, |u, l| u > l, |u, l| u > l) + }) .unwrap_or(false); // If we know the loop will be executed these instructions can still only be hoisted if the instructions // are in a non control dependent block. @@ -576,13 +576,13 @@ impl<'f> LoopInvariantContext<'f> { _ => None, }?; - let min_iter = self.inserter.function.dfg.make_constant(*lower, NumericType::length_type()); - assert!(*upper != FieldElement::zero(), "executing a non executable loop"); - let max_iter = self - .inserter - .function - .dfg - .make_constant(*upper - FieldElement::one(), NumericType::length_type()); + assert!(!upper.is_zero(), "executing a non executable loop"); + + let (upper_field, upper_type) = upper.dec().into_numeric_constant(); + let (lower_field, lower_type) = lower.into_numeric_constant(); + + let min_iter = self.inserter.function.dfg.make_constant(lower_field, lower_type); + let max_iter = self.inserter.function.dfg.make_constant(upper_field, upper_type); if (is_left && self.is_loop_invariant(rhs)) || (!is_left && self.is_loop_invariant(lhs)) { return Some((is_left, min_iter, max_iter)); } @@ -636,9 +636,9 @@ impl<'f> LoopInvariantContext<'f> { lhs: &ValueId, rhs: &ValueId, only_outer_induction: bool, - ) -> Option<(bool, FieldElement, FieldElement, FieldElement)> { - let lhs_const = self.inserter.function.dfg.get_numeric_constant_with_type(*lhs); - let rhs_const = self.inserter.function.dfg.get_numeric_constant_with_type(*rhs); + ) -> Option<(bool, IntegerConstant, IntegerConstant, IntegerConstant)> { + let lhs_const = self.inserter.function.dfg.get_integer_constant(*lhs); + let rhs_const = self.inserter.function.dfg.get_integer_constant(*rhs); match ( lhs_const, rhs_const, @@ -651,10 +651,10 @@ impl<'f> LoopInvariantContext<'f> { .and_then(|v| if only_outer_induction { None } else { Some(v) }) .or(self.outer_induction_variables.get(rhs)), ) { - (Some((lhs, _)), None, None, Some((lower_bound, upper_bound))) => { + (Some(lhs), None, None, Some((lower_bound, upper_bound))) => { Some((false, lhs, *lower_bound, *upper_bound)) } - (None, Some((rhs, _)), Some((lower_bound, upper_bound)), None) => { + (None, Some(rhs), Some((lower_bound, upper_bound)), None) => { Some((true, rhs, *lower_bound, *upper_bound)) } _ => None, @@ -707,6 +707,8 @@ impl<'f> LoopInvariantContext<'f> { // of its inputs to check whether it will ever overflow. // If so, this will cause `eval_constant_binary_op` to return `None`. // Therefore a `Some` value shows that this operation is safe. + let lhs = lhs.into_numeric_constant().0; + let rhs = rhs.into_numeric_constant().0; if eval_constant_binary_op(lhs, rhs, binary.operator, operand_type).is_some() { // Unchecked version of the binary operation let unchecked = Instruction::Binary(Binary { @@ -733,7 +735,7 @@ impl<'f> LoopInvariantContext<'f> { true if upper_bound <= value => SimplifyResult::SimplifiedTo(self.true_value), true if lower_bound >= value => SimplifyResult::SimplifiedTo(self.false_value), false if lower_bound > value => SimplifyResult::SimplifiedTo(self.true_value), - false if upper_bound <= value + FieldElement::one() => { + false if upper_bound <= value.inc() => { SimplifyResult::SimplifiedTo(self.false_value) } _ => SimplifyResult::None, @@ -760,10 +762,10 @@ impl<'f> LoopInvariantContext<'f> { return false; }; if left { - if value != FieldElement::zero() { + if !value.is_zero() { return true; } - } else if lower != FieldElement::zero() { + } else if !lower.is_zero() { return true; } diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 0abf85510cb..4d677848217 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -34,12 +34,9 @@ use crate::{ dom::DominatorTree, function::Function, function_inserter::{ArrayCache, FunctionInserter}, - instruction::{ - Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction, - binary::try_convert_field_element_to_signed_integer, - }, + instruction::{Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction}, + integer::IntegerConstant, post_order::PostOrder, - types::NumericType, value::ValueId, }, ssa_gen::Ssa, @@ -286,17 +283,6 @@ impl Loop { Self { header, back_edge_start, blocks } } - /// Handle negative values represented as fields. - fn get_const_as_i128(function: &Function, id: ValueId) -> Option { - let (value, typ) = function.dfg.get_numeric_constant_with_type(id)?; - if matches!(typ, NumericType::NativeField) { - // Shouldn't happen, as fields don't have meaningful ordering. - value.try_into_i128() - } else { - try_convert_field_element_to_signed_integer(value, typ.bit_size()) - } - } - /// Find the lower bound of the loop in the pre-header and return it /// if it's a numeric constant, which it will be if the previous SSA /// steps managed to inline it. @@ -311,9 +297,13 @@ impl Loop { /// v5 = lt v1, u32 4 /// jmpif v5 then: b3, else: b2 /// ``` - fn get_const_lower_bound(&self, function: &Function, pre_header: BasicBlockId) -> Option { + fn get_const_lower_bound( + &self, + function: &Function, + pre_header: BasicBlockId, + ) -> Option { let jump_value = get_induction_variable(function, pre_header).ok()?; - Self::get_const_as_i128(function, jump_value) + function.dfg.get_integer_constant(jump_value) } /// Find the upper bound of the loop in the loop header and return it @@ -330,7 +320,7 @@ impl Loop { /// v5 = lt v1, u32 4 // Upper bound /// jmpif v5 then: b3, else: b2 /// ``` - fn get_const_upper_bound(&self, function: &Function) -> Option { + fn get_const_upper_bound(&self, function: &Function) -> Option { let block = &function.dfg[self.header]; let instructions = block.instructions(); if instructions.is_empty() { @@ -347,14 +337,14 @@ impl Loop { match &function.dfg[instructions[0]] { Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Lt, rhs }) => { - Self::get_const_as_i128(function, *rhs) + function.dfg.get_integer_constant(*rhs) } Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Eq, rhs }) => { // `for i in 0..1` is turned into: // b1(v0: u32): // v12 = eq v0, u32 0 // jmpif v12 then: b3, else: b2 - Self::get_const_as_i128(function, *rhs).map(|c| c + 1) + function.dfg.get_integer_constant(*rhs).map(|c| c.inc()) } other => panic!("Unexpected instruction in header: {other:?}"), } @@ -365,7 +355,7 @@ impl Loop { &self, function: &Function, pre_header: BasicBlockId, - ) -> Option<(i128, i128)> { + ) -> Option<(IntegerConstant, IntegerConstant)> { let lower = self.get_const_lower_bound(function, pre_header)?; let upper = self.get_const_upper_bound(function)?; Some((lower, upper)) @@ -697,13 +687,16 @@ impl Loop { let increments = self.count_induction_increments(function); let all_instructions = self.count_all_instructions(function); - Some(BoilerplateStats { - iterations: (upper - lower).max(0) as usize, - loads, - stores, - increments, - all_instructions, - }) + // Currently we don't iterate in reverse, so if upper <= lower it means 0 iterations. + let iterations: usize = upper + .reduce( + lower, + |u, l| u.saturating_sub(l).max(0) as usize, + |u, l| u.saturating_sub(l) as usize, + ) + .unwrap_or_default(); + + Some(BoilerplateStats { iterations, loads, stores, increments, all_instructions }) } } @@ -1044,6 +1037,7 @@ mod tests { use crate::assert_ssa_snapshot; use crate::errors::RuntimeError; + use crate::ssa::ir::integer::IntegerConstant; use crate::ssa::{Ssa, ir::value::ValueId, opt::assert_normalized_ssa_equals}; use super::{BoilerplateStats, Loops, is_new_size_ok}; @@ -1170,8 +1164,8 @@ mod tests { let (lower, upper) = loop_.get_const_bounds(function, pre_header).expect("bounds are numeric const"); - assert_eq!(lower, 0); - assert_eq!(upper, 4); + assert_eq!(lower, IntegerConstant::Unsigned { value: 0, bit_size: 32 }); + assert_eq!(upper, IntegerConstant::Unsigned { value: 4, bit_size: 32 }); } #[test] diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs index 5dd52eff7ae..9a10f4e1b5c 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -534,10 +534,11 @@ impl FunctionContext<'_> { self.builder.set_location(for_expr.end_range_location); let end_index = self.codegen_non_tuple_expression(&for_expr.end_range)?; - if let (Some(start_constant), Some(end_constant)) = ( - self.builder.current_function.dfg.get_numeric_constant(start_index), - self.builder.current_function.dfg.get_numeric_constant(end_index), - ) { + let range_bound = |id| self.builder.current_function.dfg.get_integer_constant(id); + + if let (Some(start_constant), Some(end_constant)) = + (range_bound(start_index), range_bound(end_index)) + { // If we can determine that the loop contains zero iterations then there's no need to codegen the loop. if start_constant >= end_constant { return Ok(Self::unit_value()); diff --git a/test_programs/execution_success/regression_8011/Nargo.toml b/test_programs/execution_success/regression_8011/Nargo.toml new file mode 100644 index 00000000000..815e4a279bc --- /dev/null +++ b/test_programs/execution_success/regression_8011/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "regression_8011" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_success/regression_8011/Prover.toml b/test_programs/execution_success/regression_8011/Prover.toml new file mode 100644 index 00000000000..23badac2fd8 --- /dev/null +++ b/test_programs/execution_success/regression_8011/Prover.toml @@ -0,0 +1 @@ +return = 15 diff --git a/test_programs/execution_success/regression_8011/src/main.nr b/test_programs/execution_success/regression_8011/src/main.nr new file mode 100644 index 00000000000..e683b84ecd1 --- /dev/null +++ b/test_programs/execution_success/regression_8011/src/main.nr @@ -0,0 +1,26 @@ +unconstrained fn main() -> pub u32 { + let s1 = loop_with_negative_literal(); + let s2 = loop_with_u128_literal(); + assert_eq(s1, s2); + s1 +} + +fn loop_with_negative_literal() -> u32 { + let s: i64 = -5; + let e: i64 = 10; + let mut sum = 0; + for _ in s..e { + sum += 1; + } + sum +} + +fn loop_with_u128_literal() -> u32 { + let s: u128 = 170141183460469231731687303715884105715; + let e: u128 = 170141183460469231731687303715884105730; + let mut sum = 0; + for _ in s..e { + sum += 1; + } + sum +} diff --git a/test_programs/execution_success/regression_8011/stdout.txt b/test_programs/execution_success/regression_8011/stdout.txt new file mode 100644 index 00000000000..9bbe0c91cde --- /dev/null +++ b/test_programs/execution_success/regression_8011/stdout.txt @@ -0,0 +1 @@ +[regression_8011] Circuit output: Field(15) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..d7aa5c2c874 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/9VWzU6DQBBeykKLtWmjL6AXve4KFDyYYKwXE+PFg4mntZXn4NGFZDZMxwFaAaNfQnaWnX7zszNDHVHDgVWKfTjiADgt795hDWCdoHO3fDLYq37QAbE7JH+qonXAxDeg/2EAnM44/Mryj5R/NQWex6Lmx7FYu7PyOUXyEuRFy+/H9L282zhAnEPzl9DnDf7b2Co8FKPYVpZ/Mw6/nsM9Xv7CXZUIFyR/GNwcchkdXIvXIC8YPYHOaD1LEu9ItRMtiL0mH9vidVG89ygm0REvvkMPyZhTgtzU7x7Rv4DV5k0SPzPYq544Q7yC2JqLuu9kMbz9JFXK2nWLOg9czUp0jvWvYH/SEEf2Qz/zxOg8NLmJzW4XbQ3NU4UJyhPubVoX1C/K47ZwrxguOwO5nuoV8z4+uNrrw09gLL83Dr/m5pHNlV/xi/08zgbyIyV764MvakjGN2y/eqaMvmzRt7F5SN9HOlN0jvVTlJM1yEvRPKvm6Nxlzrl4XfH9e7Qp+Hh9Rh/zeUT/DtYqH28grxiffOIf9oW7D1uXh9bRX5kBld8Z7LtqNclbEXIz4Bj+tP34hpsBx/B3oHMGPKH3tIc80fx/hvbQC+J8Bvk/9dArrH16iMvXoT1k72Ho73gUm2RrEq1vI/0Z6bjrO/4FDs9oNO0PAAA=", + "debug_symbols": "ldbbioUgFAbgd/G6C11q6n6VYdh0sE0QFR0GhujdR4fdJsSb/yYw/o8FK7V1sNbX++vZj920ssfXwYapqbZ+GsPqOAtWL/0w9K/n/TXj8SHK//w6V2Ncrlu1bOyhecH82LKHsUF3/eDju/O7YMKAeQvmHZYnDuYFmKdc3sl3XgiTAokChQKNghIFBgXZryzkR0iXCocKyWEhUKGyNUhfgrRKhYAFwSLbXTJ0CSNT4VChOSwELLI7nay6hKNUlHANA9ewsHCoKDksBCwIFtnuqo9QVqfCwMKiwqj8DX2dD83T82Hy/yShL0HpLjEOrWE5WsMKWBAsJCwULDQmzrD6qZa+qgf/Hj+6fWxu08j2O/tkMJmXqfHtvvg4otymk9j1cF9LG0eD2FBrC8dDjVDnDw==", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..d7aa5c2c874 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/9VWzU6DQBBeykKLtWmjL6AXve4KFDyYYKwXE+PFg4mntZXn4NGFZDZMxwFaAaNfQnaWnX7zszNDHVHDgVWKfTjiADgt795hDWCdoHO3fDLYq37QAbE7JH+qonXAxDeg/2EAnM44/Mryj5R/NQWex6Lmx7FYu7PyOUXyEuRFy+/H9L282zhAnEPzl9DnDf7b2Co8FKPYVpZ/Mw6/nsM9Xv7CXZUIFyR/GNwcchkdXIvXIC8YPYHOaD1LEu9ItRMtiL0mH9vidVG89ygm0REvvkMPyZhTgtzU7x7Rv4DV5k0SPzPYq544Q7yC2JqLuu9kMbz9JFXK2nWLOg9czUp0jvWvYH/SEEf2Qz/zxOg8NLmJzW4XbQ3NU4UJyhPubVoX1C/K47ZwrxguOwO5nuoV8z4+uNrrw09gLL83Dr/m5pHNlV/xi/08zgbyIyV764MvakjGN2y/eqaMvmzRt7F5SN9HOlN0jvVTlJM1yEvRPKvm6Nxlzrl4XfH9e7Qp+Hh9Rh/zeUT/DtYqH28grxiffOIf9oW7D1uXh9bRX5kBld8Z7LtqNclbEXIz4Bj+tP34hpsBx/B3oHMGPKH3tIc80fx/hvbQC+J8Bvk/9dArrH16iMvXoT1k72Ho73gUm2RrEq1vI/0Z6bjrO/4FDs9oNO0PAAA=", + "debug_symbols": "ldbbioUgFAbgd/G6C11q6n6VYdh0sE0QFR0GhujdR4fdJsSb/yYw/o8FK7V1sNbX++vZj920ssfXwYapqbZ+GsPqOAtWL/0w9K/n/TXj8SHK//w6V2Ncrlu1bOyhecH82LKHsUF3/eDju/O7YMKAeQvmHZYnDuYFmKdc3sl3XgiTAokChQKNghIFBgXZryzkR0iXCocKyWEhUKGyNUhfgrRKhYAFwSLbXTJ0CSNT4VChOSwELLI7nay6hKNUlHANA9ewsHCoKDksBCwIFtnuqo9QVqfCwMKiwqj8DX2dD83T82Hy/yShL0HpLjEOrWE5WsMKWBAsJCwULDQmzrD6qZa+qgf/Hj+6fWxu08j2O/tkMJmXqfHtvvg4otymk9j1cF9LG0eD2FBrC8dDjVDnDw==", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +}